~hc/RK356X_SDK_RELEASE.git

..	..	@@ -1,3 +1,4 @@
	1	+// SPDX-License-Identifier: GPL-2.0-or-later
1	2	/*
2	3	* w83627ehf - Driver for the hardware monitoring functionality of
3	4	* the Winbond W83627EHF Super-I/O chip
..	..	@@ -17,20 +18,6 @@
17	18	* This driver also supports the W83627EHG, which is the lead-free
18	19	* version of the W83627EHF.
19	20	*
20		- * This program is free software; you can redistribute it and/or modify
21		- * it under the terms of the GNU General Public License as published by
22		- * the Free Software Foundation; either version 2 of the License, or
23		- * (at your option) any later version.
24		- *
25		- * This program is distributed in the hope that it will be useful,
26		- * but WITHOUT ANY WARRANTY; without even the implied warranty of
27		- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
28		- * GNU General Public License for more details.
29		- *
30		- * You should have received a copy of the GNU General Public License
31		- * along with this program; if not, write to the Free Software
32		- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
33		- *
34	21	* Supports the following chips:
35	22	*
36	23	* Chip #vin #fan #pwm #temp chip IDs man ID
..	..	@@ -41,8 +28,6 @@
41	28	* w83627uhg 8 2 2 3 0xa230 0xc1 0x5ca3
42	29	* w83667hg 9 5 3 3 0xa510 0xc1 0x5ca3
43	30	* w83667hg-b 9 5 3 4 0xb350 0xc1 0x5ca3
44		- * nct6775f 9 4 3 9 0xb470 0xc1 0x5ca3
45		- * nct6776f 9 5 3 9 0xC330 0xc1 0x5ca3
46	31	*/
47	32
48	33	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
..	..	@@ -63,7 +48,7 @@
63	48
64	49	enum kinds {
65	50	w83627ehf, w83627dhg, w83627dhg_p, w83627uhg,
66		- w83667hg, w83667hg_b, nct6775, nct6776,
	51	+ w83667hg, w83667hg_b,
67	52	};
68	53
69	54	/* used to set data->name = w83627ehf_device_names[data->sio_kind] */
..	..	@@ -74,17 +59,11 @@
74	59	"w83627uhg",
75	60	"w83667hg",
76	61	"w83667hg",
77		- "nct6775",
78		- "nct6776",
79	62	};
80	63
81	64	static unsigned short force_id;
82	65	module_param(force_id, ushort, 0);
83	66	MODULE_PARM_DESC(force_id, "Override the detected device ID");
84		-
85		-static unsigned short fan_debounce;
86		-module_param(fan_debounce, ushort, 0);
87		-MODULE_PARM_DESC(fan_debounce, "Enable debouncing for fan RPM signal");
88	67
89	68	#define DRVNAME "w83627ehf"
90	69
..	..	@@ -110,8 +89,6 @@
110	89	#define SIO_W83627UHG_ID 0xa230
111	90	#define SIO_W83667HG_ID 0xa510
112	91	#define SIO_W83667HG_B_ID 0xb350
113		-#define SIO_NCT6775_ID 0xb470
114		-#define SIO_NCT6776_ID 0xc330
115	92	#define SIO_ID_MASK 0xFFF0
116	93
117	94	static inline void
..	..	@@ -200,11 +177,6 @@
200	177	#define W83627EHF_REG_DIODE 0x59
201	178	#define W83627EHF_REG_SMI_OVT 0x4C
202	179
203		-/* NCT6775F has its own fan divider registers */
204		-#define NCT6775_REG_FANDIV1 0x506
205		-#define NCT6775_REG_FANDIV2 0x507
206		-#define NCT6775_REG_FAN_DEBOUNCE 0xf0
207		-
208	180	#define W83627EHF_REG_ALARM1 0x459
209	181	#define W83627EHF_REG_ALARM2 0x45A
210	182	#define W83627EHF_REG_ALARM3 0x45B
..	..	@@ -248,28 +220,6 @@
248	220
249	221	static const u16 W83627EHF_REG_TEMP_OFFSET[] = { 0x454, 0x455, 0x456 };
250	222
251		-static const u16 NCT6775_REG_TARGET[] = { 0x101, 0x201, 0x301 };
252		-static const u16 NCT6775_REG_FAN_MODE[] = { 0x102, 0x202, 0x302 };
253		-static const u16 NCT6775_REG_FAN_STOP_OUTPUT[] = { 0x105, 0x205, 0x305 };
254		-static const u16 NCT6775_REG_FAN_START_OUTPUT[] = { 0x106, 0x206, 0x306 };
255		-static const u16 NCT6775_REG_FAN_STOP_TIME[] = { 0x107, 0x207, 0x307 };
256		-static const u16 NCT6775_REG_PWM[] = { 0x109, 0x209, 0x309 };
257		-static const u16 NCT6775_REG_FAN_MAX_OUTPUT[] = { 0x10a, 0x20a, 0x30a };
258		-static const u16 NCT6775_REG_FAN_STEP_OUTPUT[] = { 0x10b, 0x20b, 0x30b };
259		-static const u16 NCT6775_REG_FAN[] = { 0x630, 0x632, 0x634, 0x636, 0x638 };
260		-static const u16 NCT6776_REG_FAN_MIN[] = { 0x63a, 0x63c, 0x63e, 0x640, 0x642};
261		-
262		-static const u16 NCT6775_REG_TEMP[]
263		- = { 0x27, 0x150, 0x250, 0x73, 0x75, 0x77, 0x62b, 0x62c, 0x62d };
264		-static const u16 NCT6775_REG_TEMP_CONFIG[]
265		- = { 0, 0x152, 0x252, 0, 0, 0, 0x628, 0x629, 0x62A };
266		-static const u16 NCT6775_REG_TEMP_HYST[]
267		- = { 0x3a, 0x153, 0x253, 0, 0, 0, 0x673, 0x678, 0x67D };
268		-static const u16 NCT6775_REG_TEMP_OVER[]
269		- = { 0x39, 0x155, 0x255, 0, 0, 0, 0x672, 0x677, 0x67C };
270		-static const u16 NCT6775_REG_TEMP_SOURCE[]
271		- = { 0x621, 0x622, 0x623, 0x100, 0x200, 0x300, 0x624, 0x625, 0x626 };
272		-
273	223	static const char *const w83667hg_b_temp_label[] = {
274	224	"SYSTIN",
275	225	"CPUTIN",
..	..	@@ -281,57 +231,7 @@
281	231	"PECI Agent 4"
282	232	};
283	233
284		-static const char *const nct6775_temp_label[] = {
285		- "",
286		- "SYSTIN",
287		- "CPUTIN",
288		- "AUXTIN",
289		- "AMD SB-TSI",
290		- "PECI Agent 0",
291		- "PECI Agent 1",
292		- "PECI Agent 2",
293		- "PECI Agent 3",
294		- "PECI Agent 4",
295		- "PECI Agent 5",
296		- "PECI Agent 6",
297		- "PECI Agent 7",
298		- "PCH_CHIP_CPU_MAX_TEMP",
299		- "PCH_CHIP_TEMP",
300		- "PCH_CPU_TEMP",
301		- "PCH_MCH_TEMP",
302		- "PCH_DIM0_TEMP",
303		- "PCH_DIM1_TEMP",
304		- "PCH_DIM2_TEMP",
305		- "PCH_DIM3_TEMP"
306		-};
307		-
308		-static const char *const nct6776_temp_label[] = {
309		- "",
310		- "SYSTIN",
311		- "CPUTIN",
312		- "AUXTIN",
313		- "SMBUSMASTER 0",
314		- "SMBUSMASTER 1",
315		- "SMBUSMASTER 2",
316		- "SMBUSMASTER 3",
317		- "SMBUSMASTER 4",
318		- "SMBUSMASTER 5",
319		- "SMBUSMASTER 6",
320		- "SMBUSMASTER 7",
321		- "PECI Agent 0",
322		- "PECI Agent 1",
323		- "PCH_CHIP_CPU_MAX_TEMP",
324		- "PCH_CHIP_TEMP",
325		- "PCH_CPU_TEMP",
326		- "PCH_MCH_TEMP",
327		- "PCH_DIM0_TEMP",
328		- "PCH_DIM1_TEMP",
329		- "PCH_DIM2_TEMP",
330		- "PCH_DIM3_TEMP",
331		- "BYTE_TEMP"
332		-};
333		-
334		-#define NUM_REG_TEMP ARRAY_SIZE(NCT6775_REG_TEMP)
	234	+#define NUM_REG_TEMP ARRAY_SIZE(W83627EHF_REG_TEMP)
335	235
336	236	static int is_word_sized(u16 reg)
337	237	{
..	..	@@ -371,31 +271,6 @@
371	271	return 1350000U / (reg << divreg);
372	272	}
373	273
374		-static unsigned int fan_from_reg13(u16 reg, unsigned int divreg)
375		-{
376		- if ((reg & 0xff1f) == 0xff1f)
377		- return 0;
378		-
379		- reg = (reg & 0x1f) \| ((reg & 0xff00) >> 3);
380		-
381		- if (reg == 0)
382		- return 0;
383		-
384		- return 1350000U / reg;
385		-}
386		-
387		-static unsigned int fan_from_reg16(u16 reg, unsigned int divreg)
388		-{
389		- if (reg == 0 \|\| reg == 0xffff)
390		- return 0;
391		-
392		- /*
393		- * Even though the registers are 16 bit wide, the fan divisor
394		- * still applies.
395		- */
396		- return 1350000U / (reg << divreg);
397		-}
398		-
399	274	static inline unsigned int
400	275	div_from_reg(u8 reg)
401	276	{
..	..	@@ -431,7 +306,6 @@
431	306	int addr; /* IO base of hw monitor block */
432	307	const char *name;
433	308
434		- struct device *hwmon_dev;
435	309	struct mutex lock;
436	310
437	311	u16 reg_temp[NUM_REG_TEMP];
..	..	@@ -441,19 +315,9 @@
441	315	u8 temp_src[NUM_REG_TEMP];
442	316	const char * const *temp_label;
443	317
444		- const u16 *REG_PWM;
445		- const u16 *REG_TARGET;
446		- const u16 *REG_FAN;
447		- const u16 *REG_FAN_MIN;
448		- const u16 *REG_FAN_START_OUTPUT;
449		- const u16 *REG_FAN_STOP_OUTPUT;
450		- const u16 *REG_FAN_STOP_TIME;
451	318	const u16 *REG_FAN_MAX_OUTPUT;
452	319	const u16 *REG_FAN_STEP_OUTPUT;
453	320	const u16 *scale_in;
454		-
455		- unsigned int (*fan_from_reg)(u16 reg, unsigned int divreg);
456		- unsigned int (*fan_from_reg_min)(u16 reg, unsigned int divreg);
457	321
458	322	struct mutex update_lock;
459	323	char valid; /* !=0 if following fields are valid */
..	..	@@ -470,7 +334,6 @@
470	334	u8 fan_div[5];
471	335	u8 has_fan; /* some fan inputs can be disabled */
472	336	u8 has_fan_min; /* some fans don't have min register */
473		- bool has_fan_div;
474	337	u8 temp_type[3];
475	338	s8 temp_offset[3];
476	339	s16 temp[9];
..	..	@@ -507,6 +370,7 @@
507	370	u16 have_temp_offset;
508	371	u8 in6_skip:1;
509	372	u8 temp3_val_only:1;
	373	+ u8 have_vid:1;
510	374
511	375	#ifdef CONFIG_PM
512	376	/* Remember extra register values over suspend/resume */
..	..	@@ -597,35 +461,6 @@
597	461	}
598	462
599	463	/* This function assumes that the caller holds data->update_lock */
600		-static void nct6775_write_fan_div(struct w83627ehf_data *data, int nr)
601		-{
602		- u8 reg;
603		-
604		- switch (nr) {
605		- case 0:
606		- reg = (w83627ehf_read_value(data, NCT6775_REG_FANDIV1) & 0x70)
607		- \| (data->fan_div[0] & 0x7);
608		- w83627ehf_write_value(data, NCT6775_REG_FANDIV1, reg);
609		- break;
610		- case 1:
611		- reg = (w83627ehf_read_value(data, NCT6775_REG_FANDIV1) & 0x7)
612		- \| ((data->fan_div[1] << 4) & 0x70);
613		- w83627ehf_write_value(data, NCT6775_REG_FANDIV1, reg);
614		- break;
615		- case 2:
616		- reg = (w83627ehf_read_value(data, NCT6775_REG_FANDIV2) & 0x70)
617		- \| (data->fan_div[2] & 0x7);
618		- w83627ehf_write_value(data, NCT6775_REG_FANDIV2, reg);
619		- break;
620		- case 3:
621		- reg = (w83627ehf_read_value(data, NCT6775_REG_FANDIV2) & 0x7)
622		- \| ((data->fan_div[3] << 4) & 0x70);
623		- w83627ehf_write_value(data, NCT6775_REG_FANDIV2, reg);
624		- break;
625		- }
626		-}
627		-
628		-/* This function assumes that the caller holds data->update_lock */
629	464	static void w83627ehf_write_fan_div(struct w83627ehf_data *data, int nr)
630	465	{
631	466	u8 reg;
..	..	@@ -676,32 +511,6 @@
676	511	}
677	512	}
678	513
679		-static void w83627ehf_write_fan_div_common(struct device *dev,
680		- struct w83627ehf_data *data, int nr)
681		-{
682		- struct w83627ehf_sio_data *sio_data = dev_get_platdata(dev);
683		-
684		- if (sio_data->kind == nct6776)
685		- ; /* no dividers, do nothing */
686		- else if (sio_data->kind == nct6775)
687		- nct6775_write_fan_div(data, nr);
688		- else
689		- w83627ehf_write_fan_div(data, nr);
690		-}
691		-
692		-static void nct6775_update_fan_div(struct w83627ehf_data *data)
693		-{
694		- u8 i;
695		-
696		- i = w83627ehf_read_value(data, NCT6775_REG_FANDIV1);
697		- data->fan_div[0] = i & 0x7;
698		- data->fan_div[1] = (i & 0x70) >> 4;
699		- i = w83627ehf_read_value(data, NCT6775_REG_FANDIV2);
700		- data->fan_div[2] = i & 0x7;
701		- if (data->has_fan & (1<<3))
702		- data->fan_div[3] = (i & 0x70) >> 4;
703		-}
704		-
705	514	static void w83627ehf_update_fan_div(struct w83627ehf_data *data)
706	515	{
707	516	int i;
..	..	@@ -727,37 +536,6 @@
727	536	}
728	537	}
729	538
730		-static void w83627ehf_update_fan_div_common(struct device *dev,
731		- struct w83627ehf_data *data)
732		-{
733		- struct w83627ehf_sio_data *sio_data = dev_get_platdata(dev);
734		-
735		- if (sio_data->kind == nct6776)
736		- ; /* no dividers, do nothing */
737		- else if (sio_data->kind == nct6775)
738		- nct6775_update_fan_div(data);
739		- else
740		- w83627ehf_update_fan_div(data);
741		-}
742		-
743		-static void nct6775_update_pwm(struct w83627ehf_data *data)
744		-{
745		- int i;
746		- int pwmcfg, fanmodecfg;
747		-
748		- for (i = 0; i < data->pwm_num; i++) {
749		- pwmcfg = w83627ehf_read_value(data,
750		- W83627EHF_REG_PWM_ENABLE[i]);
751		- fanmodecfg = w83627ehf_read_value(data,
752		- NCT6775_REG_FAN_MODE[i]);
753		- data->pwm_mode[i] =
754		- ((pwmcfg >> W83627EHF_PWM_MODE_SHIFT[i]) & 1) ? 0 : 1;
755		- data->pwm_enable[i] = ((fanmodecfg >> 4) & 7) + 1;
756		- data->tolerance[i] = fanmodecfg & 0x0f;
757		- data->pwm[i] = w83627ehf_read_value(data, data->REG_PWM[i]);
758		- }
759		-}
760		-
761	539	static void w83627ehf_update_pwm(struct w83627ehf_data *data)
762	540	{
763	541	int i;
..	..	@@ -778,28 +556,15 @@
778	556	((pwmcfg >> W83627EHF_PWM_MODE_SHIFT[i]) & 1) ? 0 : 1;
779	557	data->pwm_enable[i] = ((pwmcfg >> W83627EHF_PWM_ENABLE_SHIFT[i])
780	558	& 3) + 1;
781		- data->pwm[i] = w83627ehf_read_value(data, data->REG_PWM[i]);
	559	+ data->pwm[i] = w83627ehf_read_value(data, W83627EHF_REG_PWM[i]);
782	560
783	561	data->tolerance[i] = (tolerance >> (i == 1 ? 4 : 0)) & 0x0f;
784	562	}
785	563	}
786	564
787		-static void w83627ehf_update_pwm_common(struct device *dev,
788		- struct w83627ehf_data *data)
789		-{
790		- struct w83627ehf_sio_data *sio_data = dev_get_platdata(dev);
791		-
792		- if (sio_data->kind == nct6775 \|\| sio_data->kind == nct6776)
793		- nct6775_update_pwm(data);
794		- else
795		- w83627ehf_update_pwm(data);
796		-}
797		-
798	565	static struct w83627ehf_data w83627ehf_update_device(struct device dev)
799	566	{
800	567	struct w83627ehf_data *data = dev_get_drvdata(dev);
801		- struct w83627ehf_sio_data *sio_data = dev_get_platdata(dev);
802		-
803	568	int i;
804	569
805	570	mutex_lock(&data->update_lock);
..	..	@@ -807,7 +572,7 @@
807	572	if (time_after(jiffies, data->last_updated + HZ + HZ/2)
808	573	\|\| !data->valid) {
809	574	/* Fan clock dividers */
810		- w83627ehf_update_fan_div_common(dev, data);
	575	+ w83627ehf_update_fan_div(data);
811	576
812	577	/* Measured voltages and limits */
813	578	for (i = 0; i < data->in_num; i++) {
..	..	@@ -829,40 +594,36 @@
829	594	if (!(data->has_fan & (1 << i)))
830	595	continue;
831	596
832		- reg = w83627ehf_read_value(data, data->REG_FAN[i]);
833		- data->rpm[i] = data->fan_from_reg(reg,
834		- data->fan_div[i]);
	597	+ reg = w83627ehf_read_value(data, W83627EHF_REG_FAN[i]);
	598	+ data->rpm[i] = fan_from_reg8(reg, data->fan_div[i]);
835	599
836	600	if (data->has_fan_min & (1 << i))
837	601	data->fan_min[i] = w83627ehf_read_value(data,
838		- data->REG_FAN_MIN[i]);
	602	+ W83627EHF_REG_FAN_MIN[i]);
839	603
840	604	/*
841	605	* If we failed to measure the fan speed and clock
842	606	* divider can be increased, let's try that for next
843	607	* time
844	608	*/
845		- if (data->has_fan_div
846		- && (reg >= 0xff \|\| (sio_data->kind == nct6775
847		- && reg == 0x00))
848		- && data->fan_div[i] < 0x07) {
	609	+ if (reg >= 0xff && data->fan_div[i] < 0x07) {
849	610	dev_dbg(dev,
850	611	"Increasing fan%d clock divider from %u to %u\n",
851	612	i + 1, div_from_reg(data->fan_div[i]),
852	613	div_from_reg(data->fan_div[i] + 1));
853	614	data->fan_div[i]++;
854		- w83627ehf_write_fan_div_common(dev, data, i);
	615	+ w83627ehf_write_fan_div(data, i);
855	616	/* Preserve min limit if possible */
856	617	if ((data->has_fan_min & (1 << i))
857	618	&& data->fan_min[i] >= 2
858	619	&& data->fan_min[i] != 255)
859	620	w83627ehf_write_value(data,
860		- data->REG_FAN_MIN[i],
	621	+ W83627EHF_REG_FAN_MIN[i],
861	622	(data->fan_min[i] /= 2));
862	623	}
863	624	}
864	625
865		- w83627ehf_update_pwm_common(dev, data);
	626	+ w83627ehf_update_pwm(data);
866	627
867	628	for (i = 0; i < data->pwm_num; i++) {
868	629	if (!(data->has_fan & (1 << i)))
..	..	@@ -870,13 +631,13 @@
870	631
871	632	data->fan_start_output[i] =
872	633	w83627ehf_read_value(data,
873		- data->REG_FAN_START_OUTPUT[i]);
	634	+ W83627EHF_REG_FAN_START_OUTPUT[i]);
874	635	data->fan_stop_output[i] =
875	636	w83627ehf_read_value(data,
876		- data->REG_FAN_STOP_OUTPUT[i]);
	637	+ W83627EHF_REG_FAN_STOP_OUTPUT[i]);
877	638	data->fan_stop_time[i] =
878	639	w83627ehf_read_value(data,
879		- data->REG_FAN_STOP_TIME[i]);
	640	+ W83627EHF_REG_FAN_STOP_TIME[i]);
880	641
881	642	if (data->REG_FAN_MAX_OUTPUT &&
882	643	data->REG_FAN_MAX_OUTPUT[i] != 0xff)
..	..	@@ -892,7 +653,7 @@
892	653
893	654	data->target_temp[i] =
894	655	w83627ehf_read_value(data,
895		- data->REG_TARGET[i]) &
	656	+ W83627EHF_REG_TARGET[i]) &
896	657	(data->pwm_mode[i] == 1 ? 0x7f : 0xff);
897	658	}
898	659
..	..	@@ -936,199 +697,61 @@
936	697	return data;
937	698	}
938	699
939		-/*
940		- * Sysfs callback functions
941		- */
942		-#define show_in_reg(reg) \
943		-static ssize_t \
944		-show_##reg(struct device dev, struct device_attribute attr, \
945		- char *buf) \
946		-{ \
947		- struct w83627ehf_data *data = w83627ehf_update_device(dev); \
948		- struct sensor_device_attribute *sensor_attr = \
949		- to_sensor_dev_attr(attr); \
950		- int nr = sensor_attr->index; \
951		- return sprintf(buf, "%ld\n", in_from_reg(data->reg[nr], nr, \
952		- data->scale_in)); \
953		-}
954		-show_in_reg(in)
955		-show_in_reg(in_min)
956		-show_in_reg(in_max)
957		-
958	700	#define store_in_reg(REG, reg) \
959		-static ssize_t \
960		-store_in_##reg(struct device dev, struct device_attribute attr, \
961		- const char *buf, size_t count) \
	701	+static int \
	702	+store_in_##reg(struct device dev, struct w83627ehf_data data, int channel, \
	703	+ long val) \
962	704	{ \
963		- struct w83627ehf_data *data = dev_get_drvdata(dev); \
964		- struct sensor_device_attribute *sensor_attr = \
965		- to_sensor_dev_attr(attr); \
966		- int nr = sensor_attr->index; \
967		- unsigned long val; \
968		- int err; \
969		- err = kstrtoul(buf, 10, &val); \
970		- if (err < 0) \
971		- return err; \
	705	+ if (val < 0) \
	706	+ return -EINVAL; \
972	707	mutex_lock(&data->update_lock); \
973		- data->in_##reg[nr] = in_to_reg(val, nr, data->scale_in); \
974		- w83627ehf_write_value(data, W83627EHF_REG_IN_##REG(nr), \
975		- data->in_##reg[nr]); \
	708	+ data->in_##reg[channel] = in_to_reg(val, channel, data->scale_in); \
	709	+ w83627ehf_write_value(data, W83627EHF_REG_IN_##REG(channel), \
	710	+ data->in_##reg[channel]); \
976	711	mutex_unlock(&data->update_lock); \
977		- return count; \
	712	+ return 0; \
978	713	}
979	714
980	715	store_in_reg(MIN, min)
981	716	store_in_reg(MAX, max)
982	717
983		-static ssize_t show_alarm(struct device dev, struct device_attribute attr,
984		- char *buf)
	718	+static int
	719	+store_fan_min(struct device dev, struct w83627ehf_data data, int channel,
	720	+ long val)
985	721	{
986		- struct w83627ehf_data *data = w83627ehf_update_device(dev);
987		- struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
988		- int nr = sensor_attr->index;
989		- return sprintf(buf, "%u\n", (data->alarms >> nr) & 0x01);
990		-}
991		-
992		-static struct sensor_device_attribute sda_in_input[] = {
993		- SENSOR_ATTR(in0_input, S_IRUGO, show_in, NULL, 0),
994		- SENSOR_ATTR(in1_input, S_IRUGO, show_in, NULL, 1),
995		- SENSOR_ATTR(in2_input, S_IRUGO, show_in, NULL, 2),
996		- SENSOR_ATTR(in3_input, S_IRUGO, show_in, NULL, 3),
997		- SENSOR_ATTR(in4_input, S_IRUGO, show_in, NULL, 4),
998		- SENSOR_ATTR(in5_input, S_IRUGO, show_in, NULL, 5),
999		- SENSOR_ATTR(in6_input, S_IRUGO, show_in, NULL, 6),
1000		- SENSOR_ATTR(in7_input, S_IRUGO, show_in, NULL, 7),
1001		- SENSOR_ATTR(in8_input, S_IRUGO, show_in, NULL, 8),
1002		- SENSOR_ATTR(in9_input, S_IRUGO, show_in, NULL, 9),
1003		-};
1004		-
1005		-static struct sensor_device_attribute sda_in_alarm[] = {
1006		- SENSOR_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0),
1007		- SENSOR_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1),
1008		- SENSOR_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2),
1009		- SENSOR_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3),
1010		- SENSOR_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8),
1011		- SENSOR_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 21),
1012		- SENSOR_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 20),
1013		- SENSOR_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 16),
1014		- SENSOR_ATTR(in8_alarm, S_IRUGO, show_alarm, NULL, 17),
1015		- SENSOR_ATTR(in9_alarm, S_IRUGO, show_alarm, NULL, 19),
1016		-};
1017		-
1018		-static struct sensor_device_attribute sda_in_min[] = {
1019		- SENSOR_ATTR(in0_min, S_IWUSR \| S_IRUGO, show_in_min, store_in_min, 0),
1020		- SENSOR_ATTR(in1_min, S_IWUSR \| S_IRUGO, show_in_min, store_in_min, 1),
1021		- SENSOR_ATTR(in2_min, S_IWUSR \| S_IRUGO, show_in_min, store_in_min, 2),
1022		- SENSOR_ATTR(in3_min, S_IWUSR \| S_IRUGO, show_in_min, store_in_min, 3),
1023		- SENSOR_ATTR(in4_min, S_IWUSR \| S_IRUGO, show_in_min, store_in_min, 4),
1024		- SENSOR_ATTR(in5_min, S_IWUSR \| S_IRUGO, show_in_min, store_in_min, 5),
1025		- SENSOR_ATTR(in6_min, S_IWUSR \| S_IRUGO, show_in_min, store_in_min, 6),
1026		- SENSOR_ATTR(in7_min, S_IWUSR \| S_IRUGO, show_in_min, store_in_min, 7),
1027		- SENSOR_ATTR(in8_min, S_IWUSR \| S_IRUGO, show_in_min, store_in_min, 8),
1028		- SENSOR_ATTR(in9_min, S_IWUSR \| S_IRUGO, show_in_min, store_in_min, 9),
1029		-};
1030		-
1031		-static struct sensor_device_attribute sda_in_max[] = {
1032		- SENSOR_ATTR(in0_max, S_IWUSR \| S_IRUGO, show_in_max, store_in_max, 0),
1033		- SENSOR_ATTR(in1_max, S_IWUSR \| S_IRUGO, show_in_max, store_in_max, 1),
1034		- SENSOR_ATTR(in2_max, S_IWUSR \| S_IRUGO, show_in_max, store_in_max, 2),
1035		- SENSOR_ATTR(in3_max, S_IWUSR \| S_IRUGO, show_in_max, store_in_max, 3),
1036		- SENSOR_ATTR(in4_max, S_IWUSR \| S_IRUGO, show_in_max, store_in_max, 4),
1037		- SENSOR_ATTR(in5_max, S_IWUSR \| S_IRUGO, show_in_max, store_in_max, 5),
1038		- SENSOR_ATTR(in6_max, S_IWUSR \| S_IRUGO, show_in_max, store_in_max, 6),
1039		- SENSOR_ATTR(in7_max, S_IWUSR \| S_IRUGO, show_in_max, store_in_max, 7),
1040		- SENSOR_ATTR(in8_max, S_IWUSR \| S_IRUGO, show_in_max, store_in_max, 8),
1041		- SENSOR_ATTR(in9_max, S_IWUSR \| S_IRUGO, show_in_max, store_in_max, 9),
1042		-};
1043		-
1044		-static ssize_t
1045		-show_fan(struct device dev, struct device_attribute attr, char *buf)
1046		-{
1047		- struct w83627ehf_data *data = w83627ehf_update_device(dev);
1048		- struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1049		- int nr = sensor_attr->index;
1050		- return sprintf(buf, "%d\n", data->rpm[nr]);
1051		-}
1052		-
1053		-static ssize_t
1054		-show_fan_min(struct device dev, struct device_attribute attr, char *buf)
1055		-{
1056		- struct w83627ehf_data *data = w83627ehf_update_device(dev);
1057		- struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1058		- int nr = sensor_attr->index;
1059		- return sprintf(buf, "%d\n",
1060		- data->fan_from_reg_min(data->fan_min[nr],
1061		- data->fan_div[nr]));
1062		-}
1063		-
1064		-static ssize_t
1065		-show_fan_div(struct device dev, struct device_attribute attr,
1066		- char *buf)
1067		-{
1068		- struct w83627ehf_data *data = w83627ehf_update_device(dev);
1069		- struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1070		- int nr = sensor_attr->index;
1071		- return sprintf(buf, "%u\n", div_from_reg(data->fan_div[nr]));
1072		-}
1073		-
1074		-static ssize_t
1075		-store_fan_min(struct device dev, struct device_attribute attr,
1076		- const char *buf, size_t count)
1077		-{
1078		- struct w83627ehf_data *data = dev_get_drvdata(dev);
1079		- struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1080		- int nr = sensor_attr->index;
1081		- unsigned long val;
1082		- int err;
1083	722	unsigned int reg;
1084	723	u8 new_div;
1085	724
1086		- err = kstrtoul(buf, 10, &val);
1087		- if (err < 0)
1088		- return err;
	725	+ if (val < 0)
	726	+ return -EINVAL;
1089	727
1090	728	mutex_lock(&data->update_lock);
1091		- if (!data->has_fan_div) {
1092		- /*
1093		- * Only NCT6776F for now, so we know that this is a 13 bit
1094		- * register
1095		- */
1096		- if (!val) {
1097		- val = 0xff1f;
1098		- } else {
1099		- if (val > 1350000U)
1100		- val = 135000U;
1101		- val = 1350000U / val;
1102		- val = (val & 0x1f) \| ((val << 3) & 0xff00);
1103		- }
1104		- data->fan_min[nr] = val;
1105		- goto done; /* Leave fan divider alone */
1106		- }
1107	729	if (!val) {
1108	730	/* No min limit, alarm disabled */
1109		- data->fan_min[nr] = 255;
1110		- new_div = data->fan_div[nr]; /* No change */
1111		- dev_info(dev, "fan%u low limit and alarm disabled\n", nr + 1);
	731	+ data->fan_min[channel] = 255;
	732	+ new_div = data->fan_div[channel]; /* No change */
	733	+ dev_info(dev, "fan%u low limit and alarm disabled\n",
	734	+ channel + 1);
1112	735	} else if ((reg = 1350000U / val) >= 128 * 255) {
1113	736	/*
1114	737	* Speed below this value cannot possibly be represented,
1115	738	* even with the highest divider (128)
1116	739	*/
1117		- data->fan_min[nr] = 254;
	740	+ data->fan_min[channel] = 254;
1118	741	new_div = 7; /* 128 == (1 << 7) */
1119	742	dev_warn(dev,
1120	743	"fan%u low limit %lu below minimum %u, set to minimum\n",
1121		- nr + 1, val, data->fan_from_reg_min(254, 7));
	744	+ channel + 1, val, fan_from_reg8(254, 7));
1122	745	} else if (!reg) {
1123	746	/*
1124	747	* Speed above this value cannot possibly be represented,
1125	748	* even with the lowest divider (1)
1126	749	*/
1127		- data->fan_min[nr] = 1;
	750	+ data->fan_min[channel] = 1;
1128	751	new_div = 0; /* 1 == (1 << 0) */
1129	752	dev_warn(dev,
1130	753	"fan%u low limit %lu above maximum %u, set to maximum\n",
1131		- nr + 1, val, data->fan_from_reg_min(1, 0));
	754	+ channel + 1, val, fan_from_reg8(1, 0));
1132	755	} else {
1133	756	/*
1134	757	* Automatically pick the best divider, i.e. the one such
..	..	@@ -1140,362 +763,117 @@
1140	763	reg >>= 1;
1141	764	new_div++;
1142	765	}
1143		- data->fan_min[nr] = reg;
	766	+ data->fan_min[channel] = reg;
1144	767	}
1145	768
1146	769	/*
1147	770	* Write both the fan clock divider (if it changed) and the new
1148	771	* fan min (unconditionally)
1149	772	*/
1150		- if (new_div != data->fan_div[nr]) {
	773	+ if (new_div != data->fan_div[channel]) {
1151	774	dev_dbg(dev, "fan%u clock divider changed from %u to %u\n",
1152		- nr + 1, div_from_reg(data->fan_div[nr]),
	775	+ channel + 1, div_from_reg(data->fan_div[channel]),
1153	776	div_from_reg(new_div));
1154		- data->fan_div[nr] = new_div;
1155		- w83627ehf_write_fan_div_common(dev, data, nr);
	777	+ data->fan_div[channel] = new_div;
	778	+ w83627ehf_write_fan_div(data, channel);
1156	779	/* Give the chip time to sample a new speed value */
1157	780	data->last_updated = jiffies;
1158	781	}
1159		-done:
1160		- w83627ehf_write_value(data, data->REG_FAN_MIN[nr],
1161		- data->fan_min[nr]);
	782	+
	783	+ w83627ehf_write_value(data, W83627EHF_REG_FAN_MIN[channel],
	784	+ data->fan_min[channel]);
1162	785	mutex_unlock(&data->update_lock);
1163	786
1164		- return count;
	787	+ return 0;
1165	788	}
1166		-
1167		-static struct sensor_device_attribute sda_fan_input[] = {
1168		- SENSOR_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0),
1169		- SENSOR_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1),
1170		- SENSOR_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2),
1171		- SENSOR_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 3),
1172		- SENSOR_ATTR(fan5_input, S_IRUGO, show_fan, NULL, 4),
1173		-};
1174		-
1175		-static struct sensor_device_attribute sda_fan_alarm[] = {
1176		- SENSOR_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6),
1177		- SENSOR_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7),
1178		- SENSOR_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11),
1179		- SENSOR_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL, 10),
1180		- SENSOR_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL, 23),
1181		-};
1182		-
1183		-static struct sensor_device_attribute sda_fan_min[] = {
1184		- SENSOR_ATTR(fan1_min, S_IWUSR \| S_IRUGO, show_fan_min,
1185		- store_fan_min, 0),
1186		- SENSOR_ATTR(fan2_min, S_IWUSR \| S_IRUGO, show_fan_min,
1187		- store_fan_min, 1),
1188		- SENSOR_ATTR(fan3_min, S_IWUSR \| S_IRUGO, show_fan_min,
1189		- store_fan_min, 2),
1190		- SENSOR_ATTR(fan4_min, S_IWUSR \| S_IRUGO, show_fan_min,
1191		- store_fan_min, 3),
1192		- SENSOR_ATTR(fan5_min, S_IWUSR \| S_IRUGO, show_fan_min,
1193		- store_fan_min, 4),
1194		-};
1195		-
1196		-static struct sensor_device_attribute sda_fan_div[] = {
1197		- SENSOR_ATTR(fan1_div, S_IRUGO, show_fan_div, NULL, 0),
1198		- SENSOR_ATTR(fan2_div, S_IRUGO, show_fan_div, NULL, 1),
1199		- SENSOR_ATTR(fan3_div, S_IRUGO, show_fan_div, NULL, 2),
1200		- SENSOR_ATTR(fan4_div, S_IRUGO, show_fan_div, NULL, 3),
1201		- SENSOR_ATTR(fan5_div, S_IRUGO, show_fan_div, NULL, 4),
1202		-};
1203		-
1204		-static ssize_t
1205		-show_temp_label(struct device dev, struct device_attribute attr, char *buf)
1206		-{
1207		- struct w83627ehf_data *data = w83627ehf_update_device(dev);
1208		- struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1209		- int nr = sensor_attr->index;
1210		- return sprintf(buf, "%s\n", data->temp_label[data->temp_src[nr]]);
1211		-}
1212		-
1213		-#define show_temp_reg(addr, reg) \
1214		-static ssize_t \
1215		-show_##reg(struct device dev, struct device_attribute attr, \
1216		- char *buf) \
1217		-{ \
1218		- struct w83627ehf_data *data = w83627ehf_update_device(dev); \
1219		- struct sensor_device_attribute *sensor_attr = \
1220		- to_sensor_dev_attr(attr); \
1221		- int nr = sensor_attr->index; \
1222		- return sprintf(buf, "%d\n", LM75_TEMP_FROM_REG(data->reg[nr])); \
1223		-}
1224		-show_temp_reg(reg_temp, temp);
1225		-show_temp_reg(reg_temp_over, temp_max);
1226		-show_temp_reg(reg_temp_hyst, temp_max_hyst);
1227	789
1228	790	#define store_temp_reg(addr, reg) \
1229		-static ssize_t \
1230		-store_##reg(struct device dev, struct device_attribute attr, \
1231		- const char *buf, size_t count) \
	791	+static int \
	792	+store_##reg(struct device dev, struct w83627ehf_data data, int channel, \
	793	+ long val) \
1232	794	{ \
1233		- struct w83627ehf_data *data = dev_get_drvdata(dev); \
1234		- struct sensor_device_attribute *sensor_attr = \
1235		- to_sensor_dev_attr(attr); \
1236		- int nr = sensor_attr->index; \
1237		- int err; \
1238		- long val; \
1239		- err = kstrtol(buf, 10, &val); \
1240		- if (err < 0) \
1241		- return err; \
1242	795	mutex_lock(&data->update_lock); \
1243		- data->reg[nr] = LM75_TEMP_TO_REG(val); \
1244		- w83627ehf_write_temp(data, data->addr[nr], data->reg[nr]); \
	796	+ data->reg[channel] = LM75_TEMP_TO_REG(val); \
	797	+ w83627ehf_write_temp(data, data->addr[channel], data->reg[channel]); \
1245	798	mutex_unlock(&data->update_lock); \
1246		- return count; \
	799	+ return 0; \
1247	800	}
1248	801	store_temp_reg(reg_temp_over, temp_max);
1249	802	store_temp_reg(reg_temp_hyst, temp_max_hyst);
1250	803
1251		-static ssize_t
1252		-show_temp_offset(struct device dev, struct device_attribute attr, char *buf)
	804	+static int
	805	+store_temp_offset(struct device dev, struct w83627ehf_data data, int channel,
	806	+ long val)
1253	807	{
1254		- struct w83627ehf_data *data = w83627ehf_update_device(dev);
1255		- struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1256		-
1257		- return sprintf(buf, "%d\n",
1258		- data->temp_offset[sensor_attr->index] * 1000);
1259		-}
1260		-
1261		-static ssize_t
1262		-store_temp_offset(struct device dev, struct device_attribute attr,
1263		- const char *buf, size_t count)
1264		-{
1265		- struct w83627ehf_data *data = dev_get_drvdata(dev);
1266		- struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1267		- int nr = sensor_attr->index;
1268		- long val;
1269		- int err;
1270		-
1271		- err = kstrtol(buf, 10, &val);
1272		- if (err < 0)
1273		- return err;
1274		-
1275	808	val = clamp_val(DIV_ROUND_CLOSEST(val, 1000), -128, 127);
1276	809
1277	810	mutex_lock(&data->update_lock);
1278		- data->temp_offset[nr] = val;
1279		- w83627ehf_write_value(data, W83627EHF_REG_TEMP_OFFSET[nr], val);
	811	+ data->temp_offset[channel] = val;
	812	+ w83627ehf_write_value(data, W83627EHF_REG_TEMP_OFFSET[channel], val);
1280	813	mutex_unlock(&data->update_lock);
1281		- return count;
	814	+ return 0;
1282	815	}
1283	816
1284		-static ssize_t
1285		-show_temp_type(struct device dev, struct device_attribute attr, char *buf)
	817	+static int
	818	+store_pwm_mode(struct device dev, struct w83627ehf_data data, int channel,
	819	+ long val)
1286	820	{
1287		- struct w83627ehf_data *data = w83627ehf_update_device(dev);
1288		- struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1289		- int nr = sensor_attr->index;
1290		- return sprintf(buf, "%d\n", (int)data->temp_type[nr]);
1291		-}
1292		-
1293		-static struct sensor_device_attribute sda_temp_input[] = {
1294		- SENSOR_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0),
1295		- SENSOR_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1),
1296		- SENSOR_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 2),
1297		- SENSOR_ATTR(temp4_input, S_IRUGO, show_temp, NULL, 3),
1298		- SENSOR_ATTR(temp5_input, S_IRUGO, show_temp, NULL, 4),
1299		- SENSOR_ATTR(temp6_input, S_IRUGO, show_temp, NULL, 5),
1300		- SENSOR_ATTR(temp7_input, S_IRUGO, show_temp, NULL, 6),
1301		- SENSOR_ATTR(temp8_input, S_IRUGO, show_temp, NULL, 7),
1302		- SENSOR_ATTR(temp9_input, S_IRUGO, show_temp, NULL, 8),
1303		-};
1304		-
1305		-static struct sensor_device_attribute sda_temp_label[] = {
1306		- SENSOR_ATTR(temp1_label, S_IRUGO, show_temp_label, NULL, 0),
1307		- SENSOR_ATTR(temp2_label, S_IRUGO, show_temp_label, NULL, 1),
1308		- SENSOR_ATTR(temp3_label, S_IRUGO, show_temp_label, NULL, 2),
1309		- SENSOR_ATTR(temp4_label, S_IRUGO, show_temp_label, NULL, 3),
1310		- SENSOR_ATTR(temp5_label, S_IRUGO, show_temp_label, NULL, 4),
1311		- SENSOR_ATTR(temp6_label, S_IRUGO, show_temp_label, NULL, 5),
1312		- SENSOR_ATTR(temp7_label, S_IRUGO, show_temp_label, NULL, 6),
1313		- SENSOR_ATTR(temp8_label, S_IRUGO, show_temp_label, NULL, 7),
1314		- SENSOR_ATTR(temp9_label, S_IRUGO, show_temp_label, NULL, 8),
1315		-};
1316		-
1317		-static struct sensor_device_attribute sda_temp_max[] = {
1318		- SENSOR_ATTR(temp1_max, S_IRUGO \| S_IWUSR, show_temp_max,
1319		- store_temp_max, 0),
1320		- SENSOR_ATTR(temp2_max, S_IRUGO \| S_IWUSR, show_temp_max,
1321		- store_temp_max, 1),
1322		- SENSOR_ATTR(temp3_max, S_IRUGO \| S_IWUSR, show_temp_max,
1323		- store_temp_max, 2),
1324		- SENSOR_ATTR(temp4_max, S_IRUGO \| S_IWUSR, show_temp_max,
1325		- store_temp_max, 3),
1326		- SENSOR_ATTR(temp5_max, S_IRUGO \| S_IWUSR, show_temp_max,
1327		- store_temp_max, 4),
1328		- SENSOR_ATTR(temp6_max, S_IRUGO \| S_IWUSR, show_temp_max,
1329		- store_temp_max, 5),
1330		- SENSOR_ATTR(temp7_max, S_IRUGO \| S_IWUSR, show_temp_max,
1331		- store_temp_max, 6),
1332		- SENSOR_ATTR(temp8_max, S_IRUGO \| S_IWUSR, show_temp_max,
1333		- store_temp_max, 7),
1334		- SENSOR_ATTR(temp9_max, S_IRUGO \| S_IWUSR, show_temp_max,
1335		- store_temp_max, 8),
1336		-};
1337		-
1338		-static struct sensor_device_attribute sda_temp_max_hyst[] = {
1339		- SENSOR_ATTR(temp1_max_hyst, S_IRUGO \| S_IWUSR, show_temp_max_hyst,
1340		- store_temp_max_hyst, 0),
1341		- SENSOR_ATTR(temp2_max_hyst, S_IRUGO \| S_IWUSR, show_temp_max_hyst,
1342		- store_temp_max_hyst, 1),
1343		- SENSOR_ATTR(temp3_max_hyst, S_IRUGO \| S_IWUSR, show_temp_max_hyst,
1344		- store_temp_max_hyst, 2),
1345		- SENSOR_ATTR(temp4_max_hyst, S_IRUGO \| S_IWUSR, show_temp_max_hyst,
1346		- store_temp_max_hyst, 3),
1347		- SENSOR_ATTR(temp5_max_hyst, S_IRUGO \| S_IWUSR, show_temp_max_hyst,
1348		- store_temp_max_hyst, 4),
1349		- SENSOR_ATTR(temp6_max_hyst, S_IRUGO \| S_IWUSR, show_temp_max_hyst,
1350		- store_temp_max_hyst, 5),
1351		- SENSOR_ATTR(temp7_max_hyst, S_IRUGO \| S_IWUSR, show_temp_max_hyst,
1352		- store_temp_max_hyst, 6),
1353		- SENSOR_ATTR(temp8_max_hyst, S_IRUGO \| S_IWUSR, show_temp_max_hyst,
1354		- store_temp_max_hyst, 7),
1355		- SENSOR_ATTR(temp9_max_hyst, S_IRUGO \| S_IWUSR, show_temp_max_hyst,
1356		- store_temp_max_hyst, 8),
1357		-};
1358		-
1359		-static struct sensor_device_attribute sda_temp_alarm[] = {
1360		- SENSOR_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4),
1361		- SENSOR_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 5),
1362		- SENSOR_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 13),
1363		-};
1364		-
1365		-static struct sensor_device_attribute sda_temp_type[] = {
1366		- SENSOR_ATTR(temp1_type, S_IRUGO, show_temp_type, NULL, 0),
1367		- SENSOR_ATTR(temp2_type, S_IRUGO, show_temp_type, NULL, 1),
1368		- SENSOR_ATTR(temp3_type, S_IRUGO, show_temp_type, NULL, 2),
1369		-};
1370		-
1371		-static struct sensor_device_attribute sda_temp_offset[] = {
1372		- SENSOR_ATTR(temp1_offset, S_IRUGO \| S_IWUSR, show_temp_offset,
1373		- store_temp_offset, 0),
1374		- SENSOR_ATTR(temp2_offset, S_IRUGO \| S_IWUSR, show_temp_offset,
1375		- store_temp_offset, 1),
1376		- SENSOR_ATTR(temp3_offset, S_IRUGO \| S_IWUSR, show_temp_offset,
1377		- store_temp_offset, 2),
1378		-};
1379		-
1380		-#define show_pwm_reg(reg) \
1381		-static ssize_t show_##reg(struct device dev, struct device_attribute attr, \
1382		- char *buf) \
1383		-{ \
1384		- struct w83627ehf_data *data = w83627ehf_update_device(dev); \
1385		- struct sensor_device_attribute *sensor_attr = \
1386		- to_sensor_dev_attr(attr); \
1387		- int nr = sensor_attr->index; \
1388		- return sprintf(buf, "%d\n", data->reg[nr]); \
1389		-}
1390		-
1391		-show_pwm_reg(pwm_mode)
1392		-show_pwm_reg(pwm_enable)
1393		-show_pwm_reg(pwm)
1394		-
1395		-static ssize_t
1396		-store_pwm_mode(struct device dev, struct device_attribute attr,
1397		- const char *buf, size_t count)
1398		-{
1399		- struct w83627ehf_data *data = dev_get_drvdata(dev);
1400		- struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1401		- struct w83627ehf_sio_data *sio_data = dev_get_platdata(dev);
1402		- int nr = sensor_attr->index;
1403		- unsigned long val;
1404		- int err;
1405	821	u16 reg;
1406	822
1407		- err = kstrtoul(buf, 10, &val);
1408		- if (err < 0)
1409		- return err;
1410		-
1411		- if (val > 1)
1412		- return -EINVAL;
1413		-
1414		- /* On NCT67766F, DC mode is only supported for pwm1 */
1415		- if (sio_data->kind == nct6776 && nr && val != 1)
	823	+ if (val < 0 \|\| val > 1)
1416	824	return -EINVAL;
1417	825
1418	826	mutex_lock(&data->update_lock);
1419		- reg = w83627ehf_read_value(data, W83627EHF_REG_PWM_ENABLE[nr]);
1420		- data->pwm_mode[nr] = val;
1421		- reg &= ~(1 << W83627EHF_PWM_MODE_SHIFT[nr]);
	827	+ reg = w83627ehf_read_value(data, W83627EHF_REG_PWM_ENABLE[channel]);
	828	+ data->pwm_mode[channel] = val;
	829	+ reg &= ~(1 << W83627EHF_PWM_MODE_SHIFT[channel]);
1422	830	if (!val)
1423		- reg \|= 1 << W83627EHF_PWM_MODE_SHIFT[nr];
1424		- w83627ehf_write_value(data, W83627EHF_REG_PWM_ENABLE[nr], reg);
	831	+ reg \|= 1 << W83627EHF_PWM_MODE_SHIFT[channel];
	832	+ w83627ehf_write_value(data, W83627EHF_REG_PWM_ENABLE[channel], reg);
1425	833	mutex_unlock(&data->update_lock);
1426		- return count;
	834	+ return 0;
1427	835	}
1428	836
1429		-static ssize_t
1430		-store_pwm(struct device dev, struct device_attribute attr,
1431		- const char *buf, size_t count)
	837	+static int
	838	+store_pwm(struct device dev, struct w83627ehf_data data, int channel,
	839	+ long val)
1432	840	{
1433		- struct w83627ehf_data *data = dev_get_drvdata(dev);
1434		- struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1435		- int nr = sensor_attr->index;
1436		- unsigned long val;
1437		- int err;
1438		-
1439		- err = kstrtoul(buf, 10, &val);
1440		- if (err < 0)
1441		- return err;
1442		-
1443	841	val = clamp_val(val, 0, 255);
1444	842
1445	843	mutex_lock(&data->update_lock);
1446		- data->pwm[nr] = val;
1447		- w83627ehf_write_value(data, data->REG_PWM[nr], val);
	844	+ data->pwm[channel] = val;
	845	+ w83627ehf_write_value(data, W83627EHF_REG_PWM[channel], val);
1448	846	mutex_unlock(&data->update_lock);
1449		- return count;
	847	+ return 0;
1450	848	}
1451	849
1452		-static ssize_t
1453		-store_pwm_enable(struct device dev, struct device_attribute attr,
1454		- const char *buf, size_t count)
	850	+static int
	851	+store_pwm_enable(struct device dev, struct w83627ehf_data data, int channel,
	852	+ long val)
1455	853	{
1456		- struct w83627ehf_data *data = dev_get_drvdata(dev);
1457		- struct w83627ehf_sio_data *sio_data = dev_get_platdata(dev);
1458		- struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1459		- int nr = sensor_attr->index;
1460		- unsigned long val;
1461		- int err;
1462	854	u16 reg;
1463	855
1464		- err = kstrtoul(buf, 10, &val);
1465		- if (err < 0)
1466		- return err;
1467		-
1468		- if (!val \|\| (val > 4 && val != data->pwm_enable_orig[nr]))
1469		- return -EINVAL;
1470		- /* SmartFan III mode is not supported on NCT6776F */
1471		- if (sio_data->kind == nct6776 && val == 4)
	856	+ if (!val \|\| val < 0 \|\|
	857	+ (val > 4 && val != data->pwm_enable_orig[channel]))
1472	858	return -EINVAL;
1473	859
1474	860	mutex_lock(&data->update_lock);
1475		- data->pwm_enable[nr] = val;
1476		- if (sio_data->kind == nct6775 \|\| sio_data->kind == nct6776) {
1477		- reg = w83627ehf_read_value(data,
1478		- NCT6775_REG_FAN_MODE[nr]);
1479		- reg &= 0x0f;
1480		- reg \|= (val - 1) << 4;
1481		- w83627ehf_write_value(data,
1482		- NCT6775_REG_FAN_MODE[nr], reg);
1483		- } else {
1484		- reg = w83627ehf_read_value(data, W83627EHF_REG_PWM_ENABLE[nr]);
1485		- reg &= ~(0x03 << W83627EHF_PWM_ENABLE_SHIFT[nr]);
1486		- reg \|= (val - 1) << W83627EHF_PWM_ENABLE_SHIFT[nr];
1487		- w83627ehf_write_value(data, W83627EHF_REG_PWM_ENABLE[nr], reg);
1488		- }
	861	+ data->pwm_enable[channel] = val;
	862	+ reg = w83627ehf_read_value(data,
	863	+ W83627EHF_REG_PWM_ENABLE[channel]);
	864	+ reg &= ~(0x03 << W83627EHF_PWM_ENABLE_SHIFT[channel]);
	865	+ reg \|= (val - 1) << W83627EHF_PWM_ENABLE_SHIFT[channel];
	866	+ w83627ehf_write_value(data, W83627EHF_REG_PWM_ENABLE[channel],
	867	+ reg);
1489	868	mutex_unlock(&data->update_lock);
1490		- return count;
	869	+ return 0;
1491	870	}
1492		-
1493	871
1494	872	#define show_tol_temp(reg) \
1495	873	static ssize_t show_##reg(struct device dev, struct device_attribute attr, \
1496	874	char *buf) \
1497	875	{ \
1498		- struct w83627ehf_data *data = w83627ehf_update_device(dev); \
	876	+ struct w83627ehf_data *data = w83627ehf_update_device(dev->parent); \
1499	877	struct sensor_device_attribute *sensor_attr = \
1500	878	to_sensor_dev_attr(attr); \
1501	879	int nr = sensor_attr->index; \
..	..	@@ -1523,7 +901,7 @@
1523	901
1524	902	mutex_lock(&data->update_lock);
1525	903	data->target_temp[nr] = val;
1526		- w83627ehf_write_value(data, data->REG_TARGET[nr], val);
	904	+ w83627ehf_write_value(data, W83627EHF_REG_TARGET[nr], val);
1527	905	mutex_unlock(&data->update_lock);
1528	906	return count;
1529	907	}
..	..	@@ -1533,7 +911,6 @@
1533	911	const char *buf, size_t count)
1534	912	{
1535	913	struct w83627ehf_data *data = dev_get_drvdata(dev);
1536		- struct w83627ehf_sio_data *sio_data = dev_get_platdata(dev);
1537	914	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1538	915	int nr = sensor_attr->index;
1539	916	u16 reg;
..	..	@@ -1548,76 +925,34 @@
1548	925	val = clamp_val(DIV_ROUND_CLOSEST(val, 1000), 0, 15);
1549	926
1550	927	mutex_lock(&data->update_lock);
1551		- if (sio_data->kind == nct6775 \|\| sio_data->kind == nct6776) {
1552		- /* Limit tolerance further for NCT6776F */
1553		- if (sio_data->kind == nct6776 && val > 7)
1554		- val = 7;
1555		- reg = w83627ehf_read_value(data, NCT6775_REG_FAN_MODE[nr]);
	928	+ reg = w83627ehf_read_value(data, W83627EHF_REG_TOLERANCE[nr]);
	929	+ if (nr == 1)
	930	+ reg = (reg & 0x0f) \| (val << 4);
	931	+ else
1556	932	reg = (reg & 0xf0) \| val;
1557		- w83627ehf_write_value(data, NCT6775_REG_FAN_MODE[nr], reg);
1558		- } else {
1559		- reg = w83627ehf_read_value(data, W83627EHF_REG_TOLERANCE[nr]);
1560		- if (nr == 1)
1561		- reg = (reg & 0x0f) \| (val << 4);
1562		- else
1563		- reg = (reg & 0xf0) \| val;
1564		- w83627ehf_write_value(data, W83627EHF_REG_TOLERANCE[nr], reg);
1565		- }
	933	+ w83627ehf_write_value(data, W83627EHF_REG_TOLERANCE[nr], reg);
1566	934	data->tolerance[nr] = val;
1567	935	mutex_unlock(&data->update_lock);
1568	936	return count;
1569	937	}
1570	938
1571		-static struct sensor_device_attribute sda_pwm[] = {
1572		- SENSOR_ATTR(pwm1, S_IWUSR \| S_IRUGO, show_pwm, store_pwm, 0),
1573		- SENSOR_ATTR(pwm2, S_IWUSR \| S_IRUGO, show_pwm, store_pwm, 1),
1574		- SENSOR_ATTR(pwm3, S_IWUSR \| S_IRUGO, show_pwm, store_pwm, 2),
1575		- SENSOR_ATTR(pwm4, S_IWUSR \| S_IRUGO, show_pwm, store_pwm, 3),
1576		-};
	939	+static SENSOR_DEVICE_ATTR(pwm1_target, 0644, show_target_temp,
	940	+ store_target_temp, 0);
	941	+static SENSOR_DEVICE_ATTR(pwm2_target, 0644, show_target_temp,
	942	+ store_target_temp, 1);
	943	+static SENSOR_DEVICE_ATTR(pwm3_target, 0644, show_target_temp,
	944	+ store_target_temp, 2);
	945	+static SENSOR_DEVICE_ATTR(pwm4_target, 0644, show_target_temp,
	946	+ store_target_temp, 3);
1577	947
1578		-static struct sensor_device_attribute sda_pwm_mode[] = {
1579		- SENSOR_ATTR(pwm1_mode, S_IWUSR \| S_IRUGO, show_pwm_mode,
1580		- store_pwm_mode, 0),
1581		- SENSOR_ATTR(pwm2_mode, S_IWUSR \| S_IRUGO, show_pwm_mode,
1582		- store_pwm_mode, 1),
1583		- SENSOR_ATTR(pwm3_mode, S_IWUSR \| S_IRUGO, show_pwm_mode,
1584		- store_pwm_mode, 2),
1585		- SENSOR_ATTR(pwm4_mode, S_IWUSR \| S_IRUGO, show_pwm_mode,
1586		- store_pwm_mode, 3),
1587		-};
1588		-
1589		-static struct sensor_device_attribute sda_pwm_enable[] = {
1590		- SENSOR_ATTR(pwm1_enable, S_IWUSR \| S_IRUGO, show_pwm_enable,
1591		- store_pwm_enable, 0),
1592		- SENSOR_ATTR(pwm2_enable, S_IWUSR \| S_IRUGO, show_pwm_enable,
1593		- store_pwm_enable, 1),
1594		- SENSOR_ATTR(pwm3_enable, S_IWUSR \| S_IRUGO, show_pwm_enable,
1595		- store_pwm_enable, 2),
1596		- SENSOR_ATTR(pwm4_enable, S_IWUSR \| S_IRUGO, show_pwm_enable,
1597		- store_pwm_enable, 3),
1598		-};
1599		-
1600		-static struct sensor_device_attribute sda_target_temp[] = {
1601		- SENSOR_ATTR(pwm1_target, S_IWUSR \| S_IRUGO, show_target_temp,
1602		- store_target_temp, 0),
1603		- SENSOR_ATTR(pwm2_target, S_IWUSR \| S_IRUGO, show_target_temp,
1604		- store_target_temp, 1),
1605		- SENSOR_ATTR(pwm3_target, S_IWUSR \| S_IRUGO, show_target_temp,
1606		- store_target_temp, 2),
1607		- SENSOR_ATTR(pwm4_target, S_IWUSR \| S_IRUGO, show_target_temp,
1608		- store_target_temp, 3),
1609		-};
1610		-
1611		-static struct sensor_device_attribute sda_tolerance[] = {
1612		- SENSOR_ATTR(pwm1_tolerance, S_IWUSR \| S_IRUGO, show_tolerance,
1613		- store_tolerance, 0),
1614		- SENSOR_ATTR(pwm2_tolerance, S_IWUSR \| S_IRUGO, show_tolerance,
1615		- store_tolerance, 1),
1616		- SENSOR_ATTR(pwm3_tolerance, S_IWUSR \| S_IRUGO, show_tolerance,
1617		- store_tolerance, 2),
1618		- SENSOR_ATTR(pwm4_tolerance, S_IWUSR \| S_IRUGO, show_tolerance,
1619		- store_tolerance, 3),
1620		-};
	948	+static SENSOR_DEVICE_ATTR(pwm1_tolerance, 0644, show_tolerance,
	949	+ store_tolerance, 0);
	950	+static SENSOR_DEVICE_ATTR(pwm2_tolerance, 0644, show_tolerance,
	951	+ store_tolerance, 1);
	952	+static SENSOR_DEVICE_ATTR(pwm3_tolerance, 0644, show_tolerance,
	953	+ store_tolerance, 2);
	954	+static SENSOR_DEVICE_ATTR(pwm4_tolerance, 0644, show_tolerance,
	955	+ store_tolerance, 3);
1621	956
1622	957	/* Smart Fan registers */
1623	958
..	..	@@ -1625,7 +960,7 @@
1625	960	static ssize_t show_##reg(struct device dev, struct device_attribute attr, \
1626	961	char *buf) \
1627	962	{ \
1628		- struct w83627ehf_data *data = w83627ehf_update_device(dev); \
	963	+ struct w83627ehf_data *data = w83627ehf_update_device(dev->parent); \
1629	964	struct sensor_device_attribute *sensor_attr = \
1630	965	to_sensor_dev_attr(attr); \
1631	966	int nr = sensor_attr->index; \
..	..	@@ -1647,21 +982,21 @@
1647	982	val = clamp_val(val, 1, 255); \
1648	983	mutex_lock(&data->update_lock); \
1649	984	data->reg[nr] = val; \
1650		- w83627ehf_write_value(data, data->REG_##REG[nr], val); \
	985	+ w83627ehf_write_value(data, REG[nr], val); \
1651	986	mutex_unlock(&data->update_lock); \
1652	987	return count; \
1653	988	}
1654	989
1655		-fan_functions(fan_start_output, FAN_START_OUTPUT)
1656		-fan_functions(fan_stop_output, FAN_STOP_OUTPUT)
1657		-fan_functions(fan_max_output, FAN_MAX_OUTPUT)
1658		-fan_functions(fan_step_output, FAN_STEP_OUTPUT)
	990	+fan_functions(fan_start_output, W83627EHF_REG_FAN_START_OUTPUT)
	991	+fan_functions(fan_stop_output, W83627EHF_REG_FAN_STOP_OUTPUT)
	992	+fan_functions(fan_max_output, data->REG_FAN_MAX_OUTPUT)
	993	+fan_functions(fan_step_output, data->REG_FAN_STEP_OUTPUT)
1659	994
1660	995	#define fan_time_functions(reg, REG) \
1661	996	static ssize_t show_##reg(struct device dev, struct device_attribute attr, \
1662	997	char *buf) \
1663	998	{ \
1664		- struct w83627ehf_data *data = w83627ehf_update_device(dev); \
	999	+ struct w83627ehf_data *data = w83627ehf_update_device(dev->parent); \
1665	1000	struct sensor_device_attribute *sensor_attr = \
1666	1001	to_sensor_dev_attr(attr); \
1667	1002	int nr = sensor_attr->index; \
..	..	@@ -1686,78 +1021,61 @@
1686	1021	val = step_time_to_reg(val, data->pwm_mode[nr]); \
1687	1022	mutex_lock(&data->update_lock); \
1688	1023	data->reg[nr] = val; \
1689		- w83627ehf_write_value(data, data->REG_##REG[nr], val); \
	1024	+ w83627ehf_write_value(data, REG[nr], val); \
1690	1025	mutex_unlock(&data->update_lock); \
1691	1026	return count; \
1692	1027	} \
1693	1028
1694		-fan_time_functions(fan_stop_time, FAN_STOP_TIME)
	1029	+fan_time_functions(fan_stop_time, W83627EHF_REG_FAN_STOP_TIME)
1695	1030
1696		-static ssize_t name_show(struct device dev, struct device_attribute attr,
1697		- char *buf)
1698		-{
1699		- struct w83627ehf_data *data = dev_get_drvdata(dev);
	1031	+static SENSOR_DEVICE_ATTR(pwm4_stop_time, 0644, show_fan_stop_time,
	1032	+ store_fan_stop_time, 3);
	1033	+static SENSOR_DEVICE_ATTR(pwm4_start_output, 0644, show_fan_start_output,
	1034	+ store_fan_start_output, 3);
	1035	+static SENSOR_DEVICE_ATTR(pwm4_stop_output, 0644, show_fan_stop_output,
	1036	+ store_fan_stop_output, 3);
	1037	+static SENSOR_DEVICE_ATTR(pwm4_max_output, 0644, show_fan_max_output,
	1038	+ store_fan_max_output, 3);
	1039	+static SENSOR_DEVICE_ATTR(pwm4_step_output, 0644, show_fan_step_output,
	1040	+ store_fan_step_output, 3);
1700	1041
1701		- return sprintf(buf, "%s\n", data->name);
1702		-}
1703		-static DEVICE_ATTR_RO(name);
	1042	+static SENSOR_DEVICE_ATTR(pwm3_stop_time, 0644, show_fan_stop_time,
	1043	+ store_fan_stop_time, 2);
	1044	+static SENSOR_DEVICE_ATTR(pwm3_start_output, 0644, show_fan_start_output,
	1045	+ store_fan_start_output, 2);
	1046	+static SENSOR_DEVICE_ATTR(pwm3_stop_output, 0644, show_fan_stop_output,
	1047	+ store_fan_stop_output, 2);
1704	1048
1705		-static struct sensor_device_attribute sda_sf3_arrays_fan4[] = {
1706		- SENSOR_ATTR(pwm4_stop_time, S_IWUSR \| S_IRUGO, show_fan_stop_time,
1707		- store_fan_stop_time, 3),
1708		- SENSOR_ATTR(pwm4_start_output, S_IWUSR \| S_IRUGO, show_fan_start_output,
1709		- store_fan_start_output, 3),
1710		- SENSOR_ATTR(pwm4_stop_output, S_IWUSR \| S_IRUGO, show_fan_stop_output,
1711		- store_fan_stop_output, 3),
1712		- SENSOR_ATTR(pwm4_max_output, S_IWUSR \| S_IRUGO, show_fan_max_output,
1713		- store_fan_max_output, 3),
1714		- SENSOR_ATTR(pwm4_step_output, S_IWUSR \| S_IRUGO, show_fan_step_output,
1715		- store_fan_step_output, 3),
1716		-};
1717		-
1718		-static struct sensor_device_attribute sda_sf3_arrays_fan3[] = {
1719		- SENSOR_ATTR(pwm3_stop_time, S_IWUSR \| S_IRUGO, show_fan_stop_time,
1720		- store_fan_stop_time, 2),
1721		- SENSOR_ATTR(pwm3_start_output, S_IWUSR \| S_IRUGO, show_fan_start_output,
1722		- store_fan_start_output, 2),
1723		- SENSOR_ATTR(pwm3_stop_output, S_IWUSR \| S_IRUGO, show_fan_stop_output,
1724		- store_fan_stop_output, 2),
1725		-};
1726		-
1727		-static struct sensor_device_attribute sda_sf3_arrays[] = {
1728		- SENSOR_ATTR(pwm1_stop_time, S_IWUSR \| S_IRUGO, show_fan_stop_time,
1729		- store_fan_stop_time, 0),
1730		- SENSOR_ATTR(pwm2_stop_time, S_IWUSR \| S_IRUGO, show_fan_stop_time,
1731		- store_fan_stop_time, 1),
1732		- SENSOR_ATTR(pwm1_start_output, S_IWUSR \| S_IRUGO, show_fan_start_output,
1733		- store_fan_start_output, 0),
1734		- SENSOR_ATTR(pwm2_start_output, S_IWUSR \| S_IRUGO, show_fan_start_output,
1735		- store_fan_start_output, 1),
1736		- SENSOR_ATTR(pwm1_stop_output, S_IWUSR \| S_IRUGO, show_fan_stop_output,
1737		- store_fan_stop_output, 0),
1738		- SENSOR_ATTR(pwm2_stop_output, S_IWUSR \| S_IRUGO, show_fan_stop_output,
1739		- store_fan_stop_output, 1),
1740		-};
	1049	+static SENSOR_DEVICE_ATTR(pwm1_stop_time, 0644, show_fan_stop_time,
	1050	+ store_fan_stop_time, 0);
	1051	+static SENSOR_DEVICE_ATTR(pwm2_stop_time, 0644, show_fan_stop_time,
	1052	+ store_fan_stop_time, 1);
	1053	+static SENSOR_DEVICE_ATTR(pwm1_start_output, 0644, show_fan_start_output,
	1054	+ store_fan_start_output, 0);
	1055	+static SENSOR_DEVICE_ATTR(pwm2_start_output, 0644, show_fan_start_output,
	1056	+ store_fan_start_output, 1);
	1057	+static SENSOR_DEVICE_ATTR(pwm1_stop_output, 0644, show_fan_stop_output,
	1058	+ store_fan_stop_output, 0);
	1059	+static SENSOR_DEVICE_ATTR(pwm2_stop_output, 0644, show_fan_stop_output,
	1060	+ store_fan_stop_output, 1);
1741	1061
1742	1062
1743	1063	/*
1744	1064	* pwm1 and pwm3 don't support max and step settings on all chips.
1745	1065	* Need to check support while generating/removing attribute files.
1746	1066	*/
1747		-static struct sensor_device_attribute sda_sf3_max_step_arrays[] = {
1748		- SENSOR_ATTR(pwm1_max_output, S_IWUSR \| S_IRUGO, show_fan_max_output,
1749		- store_fan_max_output, 0),
1750		- SENSOR_ATTR(pwm1_step_output, S_IWUSR \| S_IRUGO, show_fan_step_output,
1751		- store_fan_step_output, 0),
1752		- SENSOR_ATTR(pwm2_max_output, S_IWUSR \| S_IRUGO, show_fan_max_output,
1753		- store_fan_max_output, 1),
1754		- SENSOR_ATTR(pwm2_step_output, S_IWUSR \| S_IRUGO, show_fan_step_output,
1755		- store_fan_step_output, 1),
1756		- SENSOR_ATTR(pwm3_max_output, S_IWUSR \| S_IRUGO, show_fan_max_output,
1757		- store_fan_max_output, 2),
1758		- SENSOR_ATTR(pwm3_step_output, S_IWUSR \| S_IRUGO, show_fan_step_output,
1759		- store_fan_step_output, 2),
1760		-};
	1067	+static SENSOR_DEVICE_ATTR(pwm1_max_output, 0644, show_fan_max_output,
	1068	+ store_fan_max_output, 0);
	1069	+static SENSOR_DEVICE_ATTR(pwm1_step_output, 0644, show_fan_step_output,
	1070	+ store_fan_step_output, 0);
	1071	+static SENSOR_DEVICE_ATTR(pwm2_max_output, 0644, show_fan_max_output,
	1072	+ store_fan_max_output, 1);
	1073	+static SENSOR_DEVICE_ATTR(pwm2_step_output, 0644, show_fan_step_output,
	1074	+ store_fan_step_output, 1);
	1075	+static SENSOR_DEVICE_ATTR(pwm3_max_output, 0644, show_fan_max_output,
	1076	+ store_fan_max_output, 2);
	1077	+static SENSOR_DEVICE_ATTR(pwm3_step_output, 0644, show_fan_step_output,
	1078	+ store_fan_step_output, 2);
1761	1079
1762	1080	static ssize_t
1763	1081	cpu0_vid_show(struct device dev, struct device_attribute attr, char *buf)
..	..	@@ -1765,32 +1083,19 @@
1765	1083	struct w83627ehf_data *data = dev_get_drvdata(dev);
1766	1084	return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm));
1767	1085	}
1768		-static DEVICE_ATTR_RO(cpu0_vid);
	1086	+DEVICE_ATTR_RO(cpu0_vid);
1769	1087
1770	1088
1771	1089	/* Case open detection */
1772		-
1773		-static ssize_t
1774		-show_caseopen(struct device dev, struct device_attribute attr, char *buf)
	1090	+static int
	1091	+clear_caseopen(struct device dev, struct w83627ehf_data data, int channel,
	1092	+ long val)
1775	1093	{
1776		- struct w83627ehf_data *data = w83627ehf_update_device(dev);
	1094	+ const u16 mask = 0x80;
	1095	+ u16 reg;
1777	1096
1778		- return sprintf(buf, "%d\n",
1779		- !!(data->caseopen & to_sensor_dev_attr_2(attr)->index));
1780		-}
1781		-
1782		-static ssize_t
1783		-clear_caseopen(struct device dev, struct device_attribute attr,
1784		- const char *buf, size_t count)
1785		-{
1786		- struct w83627ehf_data *data = dev_get_drvdata(dev);
1787		- unsigned long val;
1788		- u16 reg, mask;
1789		-
1790		- if (kstrtoul(buf, 10, &val) \|\| val != 0)
	1097	+ if (val != 0 \|\| channel != 0)
1791	1098	return -EINVAL;
1792		-
1793		- mask = to_sensor_dev_attr_2(attr)->nr;
1794	1099
1795	1100	mutex_lock(&data->update_lock);
1796	1101	reg = w83627ehf_read_value(data, W83627EHF_REG_CASEOPEN_CLR);
..	..	@@ -1799,85 +1104,116 @@
1799	1104	data->valid = 0; /* Force cache refresh */
1800	1105	mutex_unlock(&data->update_lock);
1801	1106
1802		- return count;
	1107	+ return 0;
1803	1108	}
1804	1109
1805		-static struct sensor_device_attribute_2 sda_caseopen[] = {
1806		- SENSOR_ATTR_2(intrusion0_alarm, S_IWUSR \| S_IRUGO, show_caseopen,
1807		- clear_caseopen, 0x80, 0x10),
1808		- SENSOR_ATTR_2(intrusion1_alarm, S_IWUSR \| S_IRUGO, show_caseopen,
1809		- clear_caseopen, 0x40, 0x40),
	1110	+static umode_t w83627ehf_attrs_visible(struct kobject *kobj,
	1111	+ struct attribute *a, int n)
	1112	+{
	1113	+ struct device *dev = container_of(kobj, struct device, kobj);
	1114	+ struct w83627ehf_data *data = dev_get_drvdata(dev);
	1115	+ struct device_attribute *devattr;
	1116	+ struct sensor_device_attribute *sda;
	1117	+
	1118	+ devattr = container_of(a, struct device_attribute, attr);
	1119	+
	1120	+ /* Not sensor */
	1121	+ if (devattr->show == cpu0_vid_show && data->have_vid)
	1122	+ return a->mode;
	1123	+
	1124	+ sda = (struct sensor_device_attribute *)devattr;
	1125	+
	1126	+ if (sda->index < 2 &&
	1127	+ (devattr->show == show_fan_stop_time \|\|
	1128	+ devattr->show == show_fan_start_output \|\|
	1129	+ devattr->show == show_fan_stop_output))
	1130	+ return a->mode;
	1131	+
	1132	+ if (sda->index < 3 &&
	1133	+ (devattr->show == show_fan_max_output \|\|
	1134	+ devattr->show == show_fan_step_output) &&
	1135	+ data->REG_FAN_STEP_OUTPUT &&
	1136	+ data->REG_FAN_STEP_OUTPUT[sda->index] != 0xff)
	1137	+ return a->mode;
	1138	+
	1139	+ /* if fan3 and fan4 are enabled create the files for them */
	1140	+ if (sda->index == 2 &&
	1141	+ (data->has_fan & (1 << 2)) && data->pwm_num >= 3 &&
	1142	+ (devattr->show == show_fan_stop_time \|\|
	1143	+ devattr->show == show_fan_start_output \|\|
	1144	+ devattr->show == show_fan_stop_output))
	1145	+ return a->mode;
	1146	+
	1147	+ if (sda->index == 3 &&
	1148	+ (data->has_fan & (1 << 3)) && data->pwm_num >= 4 &&
	1149	+ (devattr->show == show_fan_stop_time \|\|
	1150	+ devattr->show == show_fan_start_output \|\|
	1151	+ devattr->show == show_fan_stop_output \|\|
	1152	+ devattr->show == show_fan_max_output \|\|
	1153	+ devattr->show == show_fan_step_output))
	1154	+ return a->mode;
	1155	+
	1156	+ if ((devattr->show == show_target_temp \|\|
	1157	+ devattr->show == show_tolerance) &&
	1158	+ (data->has_fan & (1 << sda->index)) &&
	1159	+ sda->index < data->pwm_num)
	1160	+ return a->mode;
	1161	+
	1162	+ return 0;
	1163	+}
	1164	+
	1165	+/* These groups handle non-standard attributes used in this device */
	1166	+static struct attribute *w83627ehf_attrs[] = {
	1167	+
	1168	+ &sensor_dev_attr_pwm1_stop_time.dev_attr.attr,
	1169	+ &sensor_dev_attr_pwm1_start_output.dev_attr.attr,
	1170	+ &sensor_dev_attr_pwm1_stop_output.dev_attr.attr,
	1171	+ &sensor_dev_attr_pwm1_max_output.dev_attr.attr,
	1172	+ &sensor_dev_attr_pwm1_step_output.dev_attr.attr,
	1173	+ &sensor_dev_attr_pwm1_target.dev_attr.attr,
	1174	+ &sensor_dev_attr_pwm1_tolerance.dev_attr.attr,
	1175	+
	1176	+ &sensor_dev_attr_pwm2_stop_time.dev_attr.attr,
	1177	+ &sensor_dev_attr_pwm2_start_output.dev_attr.attr,
	1178	+ &sensor_dev_attr_pwm2_stop_output.dev_attr.attr,
	1179	+ &sensor_dev_attr_pwm2_max_output.dev_attr.attr,
	1180	+ &sensor_dev_attr_pwm2_step_output.dev_attr.attr,
	1181	+ &sensor_dev_attr_pwm2_target.dev_attr.attr,
	1182	+ &sensor_dev_attr_pwm2_tolerance.dev_attr.attr,
	1183	+
	1184	+ &sensor_dev_attr_pwm3_stop_time.dev_attr.attr,
	1185	+ &sensor_dev_attr_pwm3_start_output.dev_attr.attr,
	1186	+ &sensor_dev_attr_pwm3_stop_output.dev_attr.attr,
	1187	+ &sensor_dev_attr_pwm3_max_output.dev_attr.attr,
	1188	+ &sensor_dev_attr_pwm3_step_output.dev_attr.attr,
	1189	+ &sensor_dev_attr_pwm3_target.dev_attr.attr,
	1190	+ &sensor_dev_attr_pwm3_tolerance.dev_attr.attr,
	1191	+
	1192	+ &sensor_dev_attr_pwm4_stop_time.dev_attr.attr,
	1193	+ &sensor_dev_attr_pwm4_start_output.dev_attr.attr,
	1194	+ &sensor_dev_attr_pwm4_stop_output.dev_attr.attr,
	1195	+ &sensor_dev_attr_pwm4_max_output.dev_attr.attr,
	1196	+ &sensor_dev_attr_pwm4_step_output.dev_attr.attr,
	1197	+ &sensor_dev_attr_pwm4_target.dev_attr.attr,
	1198	+ &sensor_dev_attr_pwm4_tolerance.dev_attr.attr,
	1199	+
	1200	+ &dev_attr_cpu0_vid.attr,
	1201	+ NULL
	1202	+};
	1203	+
	1204	+static const struct attribute_group w83627ehf_group = {
	1205	+ .attrs = w83627ehf_attrs,
	1206	+ .is_visible = w83627ehf_attrs_visible,
	1207	+};
	1208	+
	1209	+static const struct attribute_group *w83627ehf_groups[] = {
	1210	+ &w83627ehf_group,
	1211	+ NULL
1810	1212	};
1811	1213
1812	1214	/*
1813	1215	* Driver and device management
1814	1216	*/
1815		-
1816		-static void w83627ehf_device_remove_files(struct device *dev)
1817		-{
1818		- /*
1819		- * some entries in the following arrays may not have been used in
1820		- * device_create_file(), but device_remove_file() will ignore them
1821		- */
1822		- int i;
1823		- struct w83627ehf_data *data = dev_get_drvdata(dev);
1824		-
1825		- for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays); i++)
1826		- device_remove_file(dev, &sda_sf3_arrays[i].dev_attr);
1827		- for (i = 0; i < ARRAY_SIZE(sda_sf3_max_step_arrays); i++) {
1828		- struct sensor_device_attribute *attr =
1829		- &sda_sf3_max_step_arrays[i];
1830		- if (data->REG_FAN_STEP_OUTPUT &&
1831		- data->REG_FAN_STEP_OUTPUT[attr->index] != 0xff)
1832		- device_remove_file(dev, &attr->dev_attr);
1833		- }
1834		- for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays_fan3); i++)
1835		- device_remove_file(dev, &sda_sf3_arrays_fan3[i].dev_attr);
1836		- for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays_fan4); i++)
1837		- device_remove_file(dev, &sda_sf3_arrays_fan4[i].dev_attr);
1838		- for (i = 0; i < data->in_num; i++) {
1839		- if ((i == 6) && data->in6_skip)
1840		- continue;
1841		- device_remove_file(dev, &sda_in_input[i].dev_attr);
1842		- device_remove_file(dev, &sda_in_alarm[i].dev_attr);
1843		- device_remove_file(dev, &sda_in_min[i].dev_attr);
1844		- device_remove_file(dev, &sda_in_max[i].dev_attr);
1845		- }
1846		- for (i = 0; i < 5; i++) {
1847		- device_remove_file(dev, &sda_fan_input[i].dev_attr);
1848		- device_remove_file(dev, &sda_fan_alarm[i].dev_attr);
1849		- device_remove_file(dev, &sda_fan_div[i].dev_attr);
1850		- device_remove_file(dev, &sda_fan_min[i].dev_attr);
1851		- }
1852		- for (i = 0; i < data->pwm_num; i++) {
1853		- device_remove_file(dev, &sda_pwm[i].dev_attr);
1854		- device_remove_file(dev, &sda_pwm_mode[i].dev_attr);
1855		- device_remove_file(dev, &sda_pwm_enable[i].dev_attr);
1856		- device_remove_file(dev, &sda_target_temp[i].dev_attr);
1857		- device_remove_file(dev, &sda_tolerance[i].dev_attr);
1858		- }
1859		- for (i = 0; i < NUM_REG_TEMP; i++) {
1860		- if (!(data->have_temp & (1 << i)))
1861		- continue;
1862		- device_remove_file(dev, &sda_temp_input[i].dev_attr);
1863		- device_remove_file(dev, &sda_temp_label[i].dev_attr);
1864		- if (i == 2 && data->temp3_val_only)
1865		- continue;
1866		- device_remove_file(dev, &sda_temp_max[i].dev_attr);
1867		- device_remove_file(dev, &sda_temp_max_hyst[i].dev_attr);
1868		- if (i > 2)
1869		- continue;
1870		- device_remove_file(dev, &sda_temp_alarm[i].dev_attr);
1871		- device_remove_file(dev, &sda_temp_type[i].dev_attr);
1872		- device_remove_file(dev, &sda_temp_offset[i].dev_attr);
1873		- }
1874		-
1875		- device_remove_file(dev, &sda_caseopen[0].dev_attr);
1876		- device_remove_file(dev, &sda_caseopen[1].dev_attr);
1877		-
1878		- device_remove_file(dev, &dev_attr_name);
1879		- device_remove_file(dev, &dev_attr_cpu0_vid);
1880		-}
1881	1217
1882	1218	/* Get the monitoring functions started */
1883	1219	static inline void w83627ehf_init_device(struct w83627ehf_data *data,
..	..	@@ -1940,16 +1276,6 @@
1940	1276	}
1941	1277	}
1942	1278
1943		-static void w82627ehf_swap_tempreg(struct w83627ehf_data *data,
1944		- int r1, int r2)
1945		-{
1946		- swap(data->temp_src[r1], data->temp_src[r2]);
1947		- swap(data->reg_temp[r1], data->reg_temp[r2]);
1948		- swap(data->reg_temp_over[r1], data->reg_temp_over[r2]);
1949		- swap(data->reg_temp_hyst[r1], data->reg_temp_hyst[r2]);
1950		- swap(data->reg_temp_config[r1], data->reg_temp_config[r2]);
1951		-}
1952		-
1953	1279	static void
1954	1280	w83627ehf_set_temp_reg_ehf(struct w83627ehf_data *data, int n_temp)
1955	1281	{
..	..	@@ -1967,7 +1293,7 @@
1967	1293	w83627ehf_check_fan_inputs(const struct w83627ehf_sio_data *sio_data,
1968	1294	struct w83627ehf_data *data)
1969	1295	{
1970		- int fan3pin, fan4pin, fan4min, fan5pin, regval;
	1296	+ int fan3pin, fan4pin, fan5pin, regval;
1971	1297
1972	1298	/* The W83627UHG is simple, only two fan inputs, no config */
1973	1299	if (sio_data->kind == w83627uhg) {
..	..	@@ -1977,76 +1303,396 @@
1977	1303	}
1978	1304
1979	1305	/* fan4 and fan5 share some pins with the GPIO and serial flash */
1980		- if (sio_data->kind == nct6775) {
1981		- /* On NCT6775, fan4 shares pins with the fdc interface */
1982		- fan3pin = 1;
1983		- fan4pin = !(superio_inb(sio_data->sioreg, 0x2A) & 0x80);
1984		- fan4min = 0;
1985		- fan5pin = 0;
1986		- } else if (sio_data->kind == nct6776) {
1987		- bool gpok = superio_inb(sio_data->sioreg, 0x27) & 0x80;
1988		-
1989		- superio_select(sio_data->sioreg, W83627EHF_LD_HWM);
1990		- regval = superio_inb(sio_data->sioreg, SIO_REG_ENABLE);
1991		-
1992		- if (regval & 0x80)
1993		- fan3pin = gpok;
1994		- else
1995		- fan3pin = !(superio_inb(sio_data->sioreg, 0x24) & 0x40);
1996		-
1997		- if (regval & 0x40)
1998		- fan4pin = gpok;
1999		- else
2000		- fan4pin = !!(superio_inb(sio_data->sioreg, 0x1C) & 0x01);
2001		-
2002		- if (regval & 0x20)
2003		- fan5pin = gpok;
2004		- else
2005		- fan5pin = !!(superio_inb(sio_data->sioreg, 0x1C) & 0x02);
2006		-
2007		- fan4min = fan4pin;
2008		- } else if (sio_data->kind == w83667hg \|\| sio_data->kind == w83667hg_b) {
	1306	+ if (sio_data->kind == w83667hg \|\| sio_data->kind == w83667hg_b) {
2009	1307	fan3pin = 1;
2010	1308	fan4pin = superio_inb(sio_data->sioreg, 0x27) & 0x40;
2011	1309	fan5pin = superio_inb(sio_data->sioreg, 0x27) & 0x20;
2012		- fan4min = fan4pin;
2013	1310	} else {
2014	1311	fan3pin = 1;
2015	1312	fan4pin = !(superio_inb(sio_data->sioreg, 0x29) & 0x06);
2016	1313	fan5pin = !(superio_inb(sio_data->sioreg, 0x24) & 0x02);
2017		- fan4min = fan4pin;
2018	1314	}
2019	1315
2020	1316	data->has_fan = data->has_fan_min = 0x03; /* fan1 and fan2 */
2021	1317	data->has_fan \|= (fan3pin << 2);
2022	1318	data->has_fan_min \|= (fan3pin << 2);
2023	1319
2024		- if (sio_data->kind == nct6775 \|\| sio_data->kind == nct6776) {
2025		- /*
2026		- * NCT6775F and NCT6776F don't have the W83627EHF_REG_FANDIV1
2027		- * register
2028		- */
2029		- data->has_fan \|= (fan4pin << 3) \| (fan5pin << 4);
2030		- data->has_fan_min \|= (fan4min << 3) \| (fan5pin << 4);
2031		- } else {
2032		- /*
2033		- * It looks like fan4 and fan5 pins can be alternatively used
2034		- * as fan on/off switches, but fan5 control is write only :/
2035		- * We assume that if the serial interface is disabled, designers
2036		- * connected fan5 as input unless they are emitting log 1, which
2037		- * is not the default.
2038		- */
2039		- regval = w83627ehf_read_value(data, W83627EHF_REG_FANDIV1);
2040		- if ((regval & (1 << 2)) && fan4pin) {
2041		- data->has_fan \|= (1 << 3);
2042		- data->has_fan_min \|= (1 << 3);
2043		- }
2044		- if (!(regval & (1 << 1)) && fan5pin) {
2045		- data->has_fan \|= (1 << 4);
2046		- data->has_fan_min \|= (1 << 4);
2047		- }
	1320	+ /*
	1321	+ * It looks like fan4 and fan5 pins can be alternatively used
	1322	+ * as fan on/off switches, but fan5 control is write only :/
	1323	+ * We assume that if the serial interface is disabled, designers
	1324	+ * connected fan5 as input unless they are emitting log 1, which
	1325	+ * is not the default.
	1326	+ */
	1327	+ regval = w83627ehf_read_value(data, W83627EHF_REG_FANDIV1);
	1328	+ if ((regval & (1 << 2)) && fan4pin) {
	1329	+ data->has_fan \|= (1 << 3);
	1330	+ data->has_fan_min \|= (1 << 3);
	1331	+ }
	1332	+ if (!(regval & (1 << 1)) && fan5pin) {
	1333	+ data->has_fan \|= (1 << 4);
	1334	+ data->has_fan_min \|= (1 << 4);
2048	1335	}
2049	1336	}
	1337	+
	1338	+static umode_t
	1339	+w83627ehf_is_visible(const void *drvdata, enum hwmon_sensor_types type,
	1340	+ u32 attr, int channel)
	1341	+{
	1342	+ const struct w83627ehf_data *data = drvdata;
	1343	+
	1344	+ switch (type) {
	1345	+ case hwmon_temp:
	1346	+ /* channel 0.., name 1.. */
	1347	+ if (!(data->have_temp & (1 << channel)))
	1348	+ return 0;
	1349	+ if (attr == hwmon_temp_input)
	1350	+ return 0444;
	1351	+ if (attr == hwmon_temp_label) {
	1352	+ if (data->temp_label)
	1353	+ return 0444;
	1354	+ return 0;
	1355	+ }
	1356	+ if (channel == 2 && data->temp3_val_only)
	1357	+ return 0;
	1358	+ if (attr == hwmon_temp_max) {
	1359	+ if (data->reg_temp_over[channel])
	1360	+ return 0644;
	1361	+ else
	1362	+ return 0;
	1363	+ }
	1364	+ if (attr == hwmon_temp_max_hyst) {
	1365	+ if (data->reg_temp_hyst[channel])
	1366	+ return 0644;
	1367	+ else
	1368	+ return 0;
	1369	+ }
	1370	+ if (channel > 2)
	1371	+ return 0;
	1372	+ if (attr == hwmon_temp_alarm \|\| attr == hwmon_temp_type)
	1373	+ return 0444;
	1374	+ if (attr == hwmon_temp_offset) {
	1375	+ if (data->have_temp_offset & (1 << channel))
	1376	+ return 0644;
	1377	+ else
	1378	+ return 0;
	1379	+ }
	1380	+ break;
	1381	+
	1382	+ case hwmon_fan:
	1383	+ /* channel 0.., name 1.. */
	1384	+ if (!(data->has_fan & (1 << channel)))
	1385	+ return 0;
	1386	+ if (attr == hwmon_fan_input \|\| attr == hwmon_fan_alarm)
	1387	+ return 0444;
	1388	+ if (attr == hwmon_fan_div) {
	1389	+ return 0444;
	1390	+ }
	1391	+ if (attr == hwmon_fan_min) {
	1392	+ if (data->has_fan_min & (1 << channel))
	1393	+ return 0644;
	1394	+ else
	1395	+ return 0;
	1396	+ }
	1397	+ break;
	1398	+
	1399	+ case hwmon_in:
	1400	+ /* channel 0.., name 0.. */
	1401	+ if (channel >= data->in_num)
	1402	+ return 0;
	1403	+ if (channel == 6 && data->in6_skip)
	1404	+ return 0;
	1405	+ if (attr == hwmon_in_alarm \|\| attr == hwmon_in_input)
	1406	+ return 0444;
	1407	+ if (attr == hwmon_in_min \|\| attr == hwmon_in_max)
	1408	+ return 0644;
	1409	+ break;
	1410	+
	1411	+ case hwmon_pwm:
	1412	+ /* channel 0.., name 1.. */
	1413	+ if (!(data->has_fan & (1 << channel)) \|\|
	1414	+ channel >= data->pwm_num)
	1415	+ return 0;
	1416	+ if (attr == hwmon_pwm_mode \|\| attr == hwmon_pwm_enable \|\|
	1417	+ attr == hwmon_pwm_input)
	1418	+ return 0644;
	1419	+ break;
	1420	+
	1421	+ case hwmon_intrusion:
	1422	+ return 0644;
	1423	+
	1424	+ default: /* Shouldn't happen */
	1425	+ return 0;
	1426	+ }
	1427	+
	1428	+ return 0; /* Shouldn't happen */
	1429	+}
	1430	+
	1431	+static int
	1432	+w83627ehf_do_read_temp(struct w83627ehf_data *data, u32 attr,
	1433	+ int channel, long *val)
	1434	+{
	1435	+ switch (attr) {
	1436	+ case hwmon_temp_input:
	1437	+ *val = LM75_TEMP_FROM_REG(data->temp[channel]);
	1438	+ return 0;
	1439	+ case hwmon_temp_max:
	1440	+ *val = LM75_TEMP_FROM_REG(data->temp_max[channel]);
	1441	+ return 0;
	1442	+ case hwmon_temp_max_hyst:
	1443	+ *val = LM75_TEMP_FROM_REG(data->temp_max_hyst[channel]);
	1444	+ return 0;
	1445	+ case hwmon_temp_offset:
	1446	+ val = data->temp_offset[channel] 1000;
	1447	+ return 0;
	1448	+ case hwmon_temp_type:
	1449	+ *val = (int)data->temp_type[channel];
	1450	+ return 0;
	1451	+ case hwmon_temp_alarm:
	1452	+ if (channel < 3) {
	1453	+ int bit[] = { 4, 5, 13 };
	1454	+ *val = (data->alarms >> bit[channel]) & 1;
	1455	+ return 0;
	1456	+ }
	1457	+ break;
	1458	+
	1459	+ default:
	1460	+ break;
	1461	+ }
	1462	+
	1463	+ return -EOPNOTSUPP;
	1464	+}
	1465	+
	1466	+static int
	1467	+w83627ehf_do_read_in(struct w83627ehf_data *data, u32 attr,
	1468	+ int channel, long *val)
	1469	+{
	1470	+ switch (attr) {
	1471	+ case hwmon_in_input:
	1472	+ *val = in_from_reg(data->in[channel], channel, data->scale_in);
	1473	+ return 0;
	1474	+ case hwmon_in_min:
	1475	+ *val = in_from_reg(data->in_min[channel], channel,
	1476	+ data->scale_in);
	1477	+ return 0;
	1478	+ case hwmon_in_max:
	1479	+ *val = in_from_reg(data->in_max[channel], channel,
	1480	+ data->scale_in);
	1481	+ return 0;
	1482	+ case hwmon_in_alarm:
	1483	+ if (channel < 10) {
	1484	+ int bit[] = { 0, 1, 2, 3, 8, 21, 20, 16, 17, 19 };
	1485	+ *val = (data->alarms >> bit[channel]) & 1;
	1486	+ return 0;
	1487	+ }
	1488	+ break;
	1489	+ default:
	1490	+ break;
	1491	+ }
	1492	+ return -EOPNOTSUPP;
	1493	+}
	1494	+
	1495	+static int
	1496	+w83627ehf_do_read_fan(struct w83627ehf_data *data, u32 attr,
	1497	+ int channel, long *val)
	1498	+{
	1499	+ switch (attr) {
	1500	+ case hwmon_fan_input:
	1501	+ *val = data->rpm[channel];
	1502	+ return 0;
	1503	+ case hwmon_fan_min:
	1504	+ *val = fan_from_reg8(data->fan_min[channel],
	1505	+ data->fan_div[channel]);
	1506	+ return 0;
	1507	+ case hwmon_fan_div:
	1508	+ *val = div_from_reg(data->fan_div[channel]);
	1509	+ return 0;
	1510	+ case hwmon_fan_alarm:
	1511	+ if (channel < 5) {
	1512	+ int bit[] = { 6, 7, 11, 10, 23 };
	1513	+ *val = (data->alarms >> bit[channel]) & 1;
	1514	+ return 0;
	1515	+ }
	1516	+ break;
	1517	+ default:
	1518	+ break;
	1519	+ }
	1520	+ return -EOPNOTSUPP;
	1521	+}
	1522	+
	1523	+static int
	1524	+w83627ehf_do_read_pwm(struct w83627ehf_data *data, u32 attr,
	1525	+ int channel, long *val)
	1526	+{
	1527	+ switch (attr) {
	1528	+ case hwmon_pwm_input:
	1529	+ *val = data->pwm[channel];
	1530	+ return 0;
	1531	+ case hwmon_pwm_enable:
	1532	+ *val = data->pwm_enable[channel];
	1533	+ return 0;
	1534	+ case hwmon_pwm_mode:
	1535	+ *val = data->pwm_enable[channel];
	1536	+ return 0;
	1537	+ default:
	1538	+ break;
	1539	+ }
	1540	+ return -EOPNOTSUPP;
	1541	+}
	1542	+
	1543	+static int
	1544	+w83627ehf_do_read_intrusion(struct w83627ehf_data *data, u32 attr,
	1545	+ int channel, long *val)
	1546	+{
	1547	+ if (attr != hwmon_intrusion_alarm \|\| channel != 0)
	1548	+ return -EOPNOTSUPP; /* shouldn't happen */
	1549	+
	1550	+ *val = !!(data->caseopen & 0x10);
	1551	+ return 0;
	1552	+}
	1553	+
	1554	+static int
	1555	+w83627ehf_read(struct device *dev, enum hwmon_sensor_types type,
	1556	+ u32 attr, int channel, long *val)
	1557	+{
	1558	+ struct w83627ehf_data *data = w83627ehf_update_device(dev->parent);
	1559	+
	1560	+ switch (type) {
	1561	+ case hwmon_fan:
	1562	+ return w83627ehf_do_read_fan(data, attr, channel, val);
	1563	+
	1564	+ case hwmon_in:
	1565	+ return w83627ehf_do_read_in(data, attr, channel, val);
	1566	+
	1567	+ case hwmon_pwm:
	1568	+ return w83627ehf_do_read_pwm(data, attr, channel, val);
	1569	+
	1570	+ case hwmon_temp:
	1571	+ return w83627ehf_do_read_temp(data, attr, channel, val);
	1572	+
	1573	+ case hwmon_intrusion:
	1574	+ return w83627ehf_do_read_intrusion(data, attr, channel, val);
	1575	+
	1576	+ default:
	1577	+ break;
	1578	+ }
	1579	+
	1580	+ return -EOPNOTSUPP;
	1581	+}
	1582	+
	1583	+static int
	1584	+w83627ehf_read_string(struct device *dev, enum hwmon_sensor_types type,
	1585	+ u32 attr, int channel, const char **str)
	1586	+{
	1587	+ struct w83627ehf_data *data = dev_get_drvdata(dev);
	1588	+
	1589	+ switch (type) {
	1590	+ case hwmon_temp:
	1591	+ if (attr == hwmon_temp_label) {
	1592	+ *str = data->temp_label[data->temp_src[channel]];
	1593	+ return 0;
	1594	+ }
	1595	+ break;
	1596	+
	1597	+ default:
	1598	+ break;
	1599	+ }
	1600	+ /* Nothing else should be read as a string */
	1601	+ return -EOPNOTSUPP;
	1602	+}
	1603	+
	1604	+static int
	1605	+w83627ehf_write(struct device *dev, enum hwmon_sensor_types type,
	1606	+ u32 attr, int channel, long val)
	1607	+{
	1608	+ struct w83627ehf_data *data = dev_get_drvdata(dev);
	1609	+
	1610	+ if (type == hwmon_in && attr == hwmon_in_min)
	1611	+ return store_in_min(dev, data, channel, val);
	1612	+ if (type == hwmon_in && attr == hwmon_in_max)
	1613	+ return store_in_max(dev, data, channel, val);
	1614	+
	1615	+ if (type == hwmon_fan && attr == hwmon_fan_min)
	1616	+ return store_fan_min(dev, data, channel, val);
	1617	+
	1618	+ if (type == hwmon_temp && attr == hwmon_temp_max)
	1619	+ return store_temp_max(dev, data, channel, val);
	1620	+ if (type == hwmon_temp && attr == hwmon_temp_max_hyst)
	1621	+ return store_temp_max_hyst(dev, data, channel, val);
	1622	+ if (type == hwmon_temp && attr == hwmon_temp_offset)
	1623	+ return store_temp_offset(dev, data, channel, val);
	1624	+
	1625	+ if (type == hwmon_pwm && attr == hwmon_pwm_mode)
	1626	+ return store_pwm_mode(dev, data, channel, val);
	1627	+ if (type == hwmon_pwm && attr == hwmon_pwm_enable)
	1628	+ return store_pwm_enable(dev, data, channel, val);
	1629	+ if (type == hwmon_pwm && attr == hwmon_pwm_input)
	1630	+ return store_pwm(dev, data, channel, val);
	1631	+
	1632	+ if (type == hwmon_intrusion && attr == hwmon_intrusion_alarm)
	1633	+ return clear_caseopen(dev, data, channel, val);
	1634	+
	1635	+ return -EOPNOTSUPP;
	1636	+}
	1637	+
	1638	+static const struct hwmon_ops w83627ehf_ops = {
	1639	+ .is_visible = w83627ehf_is_visible,
	1640	+ .read = w83627ehf_read,
	1641	+ .read_string = w83627ehf_read_string,
	1642	+ .write = w83627ehf_write,
	1643	+};
	1644	+
	1645	+static const struct hwmon_channel_info *w83627ehf_info[] = {
	1646	+ HWMON_CHANNEL_INFO(fan,
	1647	+ HWMON_F_ALARM \| HWMON_F_DIV \| HWMON_F_INPUT \| HWMON_F_MIN,
	1648	+ HWMON_F_ALARM \| HWMON_F_DIV \| HWMON_F_INPUT \| HWMON_F_MIN,
	1649	+ HWMON_F_ALARM \| HWMON_F_DIV \| HWMON_F_INPUT \| HWMON_F_MIN,
	1650	+ HWMON_F_ALARM \| HWMON_F_DIV \| HWMON_F_INPUT \| HWMON_F_MIN,
	1651	+ HWMON_F_ALARM \| HWMON_F_DIV \| HWMON_F_INPUT \| HWMON_F_MIN),
	1652	+ HWMON_CHANNEL_INFO(in,
	1653	+ HWMON_I_ALARM \| HWMON_I_INPUT \| HWMON_I_MAX \| HWMON_I_MIN,
	1654	+ HWMON_I_ALARM \| HWMON_I_INPUT \| HWMON_I_MAX \| HWMON_I_MIN,
	1655	+ HWMON_I_ALARM \| HWMON_I_INPUT \| HWMON_I_MAX \| HWMON_I_MIN,
	1656	+ HWMON_I_ALARM \| HWMON_I_INPUT \| HWMON_I_MAX \| HWMON_I_MIN,
	1657	+ HWMON_I_ALARM \| HWMON_I_INPUT \| HWMON_I_MAX \| HWMON_I_MIN,
	1658	+ HWMON_I_ALARM \| HWMON_I_INPUT \| HWMON_I_MAX \| HWMON_I_MIN,
	1659	+ HWMON_I_ALARM \| HWMON_I_INPUT \| HWMON_I_MAX \| HWMON_I_MIN,
	1660	+ HWMON_I_ALARM \| HWMON_I_INPUT \| HWMON_I_MAX \| HWMON_I_MIN,
	1661	+ HWMON_I_ALARM \| HWMON_I_INPUT \| HWMON_I_MAX \| HWMON_I_MIN,
	1662	+ HWMON_I_ALARM \| HWMON_I_INPUT \| HWMON_I_MAX \| HWMON_I_MIN),
	1663	+ HWMON_CHANNEL_INFO(pwm,
	1664	+ HWMON_PWM_ENABLE \| HWMON_PWM_INPUT \| HWMON_PWM_MODE,
	1665	+ HWMON_PWM_ENABLE \| HWMON_PWM_INPUT \| HWMON_PWM_MODE,
	1666	+ HWMON_PWM_ENABLE \| HWMON_PWM_INPUT \| HWMON_PWM_MODE,
	1667	+ HWMON_PWM_ENABLE \| HWMON_PWM_INPUT \| HWMON_PWM_MODE),
	1668	+ HWMON_CHANNEL_INFO(temp,
	1669	+ HWMON_T_ALARM \| HWMON_T_INPUT \| HWMON_T_LABEL \| HWMON_T_MAX \|
	1670	+ HWMON_T_MAX_HYST \| HWMON_T_OFFSET \| HWMON_T_TYPE,
	1671	+ HWMON_T_ALARM \| HWMON_T_INPUT \| HWMON_T_LABEL \| HWMON_T_MAX \|
	1672	+ HWMON_T_MAX_HYST \| HWMON_T_OFFSET \| HWMON_T_TYPE,
	1673	+ HWMON_T_ALARM \| HWMON_T_INPUT \| HWMON_T_LABEL \| HWMON_T_MAX \|
	1674	+ HWMON_T_MAX_HYST \| HWMON_T_OFFSET \| HWMON_T_TYPE,
	1675	+ HWMON_T_ALARM \| HWMON_T_INPUT \| HWMON_T_LABEL \| HWMON_T_MAX \|
	1676	+ HWMON_T_MAX_HYST \| HWMON_T_OFFSET \| HWMON_T_TYPE,
	1677	+ HWMON_T_ALARM \| HWMON_T_INPUT \| HWMON_T_LABEL \| HWMON_T_MAX \|
	1678	+ HWMON_T_MAX_HYST \| HWMON_T_OFFSET \| HWMON_T_TYPE,
	1679	+ HWMON_T_ALARM \| HWMON_T_INPUT \| HWMON_T_LABEL \| HWMON_T_MAX \|
	1680	+ HWMON_T_MAX_HYST \| HWMON_T_OFFSET \| HWMON_T_TYPE,
	1681	+ HWMON_T_ALARM \| HWMON_T_INPUT \| HWMON_T_LABEL \| HWMON_T_MAX \|
	1682	+ HWMON_T_MAX_HYST \| HWMON_T_OFFSET \| HWMON_T_TYPE,
	1683	+ HWMON_T_ALARM \| HWMON_T_INPUT \| HWMON_T_LABEL \| HWMON_T_MAX \|
	1684	+ HWMON_T_MAX_HYST \| HWMON_T_OFFSET \| HWMON_T_TYPE,
	1685	+ HWMON_T_ALARM \| HWMON_T_INPUT \| HWMON_T_LABEL \| HWMON_T_MAX \|
	1686	+ HWMON_T_MAX_HYST \| HWMON_T_OFFSET \| HWMON_T_TYPE),
	1687	+ HWMON_CHANNEL_INFO(intrusion,
	1688	+ HWMON_INTRUSION_ALARM),
	1689	+ NULL
	1690	+};
	1691	+
	1692	+static const struct hwmon_chip_info w83627ehf_chip_info = {
	1693	+ .ops = &w83627ehf_ops,
	1694	+ .info = w83627ehf_info,
	1695	+};
2050	1696
2051	1697	static int w83627ehf_probe(struct platform_device *pdev)
2052	1698	{
..	..	@@ -2056,6 +1702,7 @@
2056	1702	struct resource *res;
2057	1703	u8 en_vrm10;
2058	1704	int i, err = 0;
	1705	+ struct device *hwmon_dev;
2059	1706
2060	1707	res = platform_get_resource(pdev, IORESOURCE_IO, 0);
2061	1708	if (!request_region(res->start, IOREGION_LENGTH, DRVNAME)) {
..	..	@@ -2082,15 +1729,13 @@
2082	1729
2083	1730	/* 627EHG and 627EHF have 10 voltage inputs; 627DHG and 667HG have 9 */
2084	1731	data->in_num = (sio_data->kind == w83627ehf) ? 10 : 9;
2085		- /* 667HG, NCT6775F, and NCT6776F have 3 pwms, and 627UHG has only 2 */
	1732	+ /* 667HG has 3 pwms, and 627UHG has only 2 */
2086	1733	switch (sio_data->kind) {
2087	1734	default:
2088	1735	data->pwm_num = 4;
2089	1736	break;
2090	1737	case w83667hg:
2091	1738	case w83667hg_b:
2092		- case nct6775:
2093		- case nct6776:
2094	1739	data->pwm_num = 3;
2095	1740	break;
2096	1741	case w83627uhg:
..	..	@@ -2102,83 +1747,7 @@
2102	1747	data->have_temp = 0x07;
2103	1748
2104	1749	/* Deal with temperature register setup first. */
2105		- if (sio_data->kind == nct6775 \|\| sio_data->kind == nct6776) {
2106		- int mask = 0;
2107		-
2108		- /*
2109		- * Display temperature sensor output only if it monitors
2110		- * a source other than one already reported. Always display
2111		- * first three temperature registers, though.
2112		- */
2113		- for (i = 0; i < NUM_REG_TEMP; i++) {
2114		- u8 src;
2115		-
2116		- data->reg_temp[i] = NCT6775_REG_TEMP[i];
2117		- data->reg_temp_over[i] = NCT6775_REG_TEMP_OVER[i];
2118		- data->reg_temp_hyst[i] = NCT6775_REG_TEMP_HYST[i];
2119		- data->reg_temp_config[i] = NCT6775_REG_TEMP_CONFIG[i];
2120		-
2121		- src = w83627ehf_read_value(data,
2122		- NCT6775_REG_TEMP_SOURCE[i]);
2123		- src &= 0x1f;
2124		- if (src && !(mask & (1 << src))) {
2125		- data->have_temp \|= 1 << i;
2126		- mask \|= 1 << src;
2127		- }
2128		-
2129		- data->temp_src[i] = src;
2130		-
2131		- /*
2132		- * Now do some register swapping if index 0..2 don't
2133		- * point to SYSTIN(1), CPUIN(2), and AUXIN(3).
2134		- * Idea is to have the first three attributes
2135		- * report SYSTIN, CPUIN, and AUXIN if possible
2136		- * without overriding the basic system configuration.
2137		- */
2138		- if (i > 0 && data->temp_src[0] != 1
2139		- && data->temp_src[i] == 1)
2140		- w82627ehf_swap_tempreg(data, 0, i);
2141		- if (i > 1 && data->temp_src[1] != 2
2142		- && data->temp_src[i] == 2)
2143		- w82627ehf_swap_tempreg(data, 1, i);
2144		- if (i > 2 && data->temp_src[2] != 3
2145		- && data->temp_src[i] == 3)
2146		- w82627ehf_swap_tempreg(data, 2, i);
2147		- }
2148		- if (sio_data->kind == nct6776) {
2149		- /*
2150		- * On NCT6776, AUXTIN and VIN3 pins are shared.
2151		- * Only way to detect it is to check if AUXTIN is used
2152		- * as a temperature source, and if that source is
2153		- * enabled.
2154		- *
2155		- * If that is the case, disable in6, which reports VIN3.
2156		- * Otherwise disable temp3.
2157		- */
2158		- if (data->temp_src[2] == 3) {
2159		- u8 reg;
2160		-
2161		- if (data->reg_temp_config[2])
2162		- reg = w83627ehf_read_value(data,
2163		- data->reg_temp_config[2]);
2164		- else
2165		- reg = 0; /* Assume AUXTIN is used */
2166		-
2167		- if (reg & 0x01)
2168		- data->have_temp &= ~(1 << 2);
2169		- else
2170		- data->in6_skip = 1;
2171		- }
2172		- data->temp_label = nct6776_temp_label;
2173		- } else {
2174		- data->temp_label = nct6775_temp_label;
2175		- }
2176		- data->have_temp_offset = data->have_temp & 0x07;
2177		- for (i = 0; i < 3; i++) {
2178		- if (data->temp_src[i] > 3)
2179		- data->have_temp_offset &= ~(1 << i);
2180		- }
2181		- } else if (sio_data->kind == w83667hg_b) {
	1750	+ if (sio_data->kind == w83667hg_b) {
2182	1751	u8 reg;
2183	1752
2184	1753	w83627ehf_set_temp_reg_ehf(data, 4);
..	..	@@ -2288,56 +1857,12 @@
2288	1857	data->have_temp_offset = data->have_temp & 0x07;
2289	1858	}
2290	1859
2291		- if (sio_data->kind == nct6775) {
2292		- data->has_fan_div = true;
2293		- data->fan_from_reg = fan_from_reg16;
2294		- data->fan_from_reg_min = fan_from_reg8;
2295		- data->REG_PWM = NCT6775_REG_PWM;
2296		- data->REG_TARGET = NCT6775_REG_TARGET;
2297		- data->REG_FAN = NCT6775_REG_FAN;
2298		- data->REG_FAN_MIN = W83627EHF_REG_FAN_MIN;
2299		- data->REG_FAN_START_OUTPUT = NCT6775_REG_FAN_START_OUTPUT;
2300		- data->REG_FAN_STOP_OUTPUT = NCT6775_REG_FAN_STOP_OUTPUT;
2301		- data->REG_FAN_STOP_TIME = NCT6775_REG_FAN_STOP_TIME;
2302		- data->REG_FAN_MAX_OUTPUT = NCT6775_REG_FAN_MAX_OUTPUT;
2303		- data->REG_FAN_STEP_OUTPUT = NCT6775_REG_FAN_STEP_OUTPUT;
2304		- } else if (sio_data->kind == nct6776) {
2305		- data->has_fan_div = false;
2306		- data->fan_from_reg = fan_from_reg13;
2307		- data->fan_from_reg_min = fan_from_reg13;
2308		- data->REG_PWM = NCT6775_REG_PWM;
2309		- data->REG_TARGET = NCT6775_REG_TARGET;
2310		- data->REG_FAN = NCT6775_REG_FAN;
2311		- data->REG_FAN_MIN = NCT6776_REG_FAN_MIN;
2312		- data->REG_FAN_START_OUTPUT = NCT6775_REG_FAN_START_OUTPUT;
2313		- data->REG_FAN_STOP_OUTPUT = NCT6775_REG_FAN_STOP_OUTPUT;
2314		- data->REG_FAN_STOP_TIME = NCT6775_REG_FAN_STOP_TIME;
2315		- } else if (sio_data->kind == w83667hg_b) {
2316		- data->has_fan_div = true;
2317		- data->fan_from_reg = fan_from_reg8;
2318		- data->fan_from_reg_min = fan_from_reg8;
2319		- data->REG_PWM = W83627EHF_REG_PWM;
2320		- data->REG_TARGET = W83627EHF_REG_TARGET;
2321		- data->REG_FAN = W83627EHF_REG_FAN;
2322		- data->REG_FAN_MIN = W83627EHF_REG_FAN_MIN;
2323		- data->REG_FAN_START_OUTPUT = W83627EHF_REG_FAN_START_OUTPUT;
2324		- data->REG_FAN_STOP_OUTPUT = W83627EHF_REG_FAN_STOP_OUTPUT;
2325		- data->REG_FAN_STOP_TIME = W83627EHF_REG_FAN_STOP_TIME;
	1860	+ if (sio_data->kind == w83667hg_b) {
2326	1861	data->REG_FAN_MAX_OUTPUT =
2327	1862	W83627EHF_REG_FAN_MAX_OUTPUT_W83667_B;
2328	1863	data->REG_FAN_STEP_OUTPUT =
2329	1864	W83627EHF_REG_FAN_STEP_OUTPUT_W83667_B;
2330	1865	} else {
2331		- data->has_fan_div = true;
2332		- data->fan_from_reg = fan_from_reg8;
2333		- data->fan_from_reg_min = fan_from_reg8;
2334		- data->REG_PWM = W83627EHF_REG_PWM;
2335		- data->REG_TARGET = W83627EHF_REG_TARGET;
2336		- data->REG_FAN = W83627EHF_REG_FAN;
2337		- data->REG_FAN_MIN = W83627EHF_REG_FAN_MIN;
2338		- data->REG_FAN_START_OUTPUT = W83627EHF_REG_FAN_START_OUTPUT;
2339		- data->REG_FAN_STOP_OUTPUT = W83627EHF_REG_FAN_STOP_OUTPUT;
2340		- data->REG_FAN_STOP_TIME = W83627EHF_REG_FAN_STOP_TIME;
2341	1866	data->REG_FAN_MAX_OUTPUT =
2342	1867	W83627EHF_REG_FAN_MAX_OUTPUT_COMMON;
2343	1868	data->REG_FAN_STEP_OUTPUT =
..	..	@@ -2360,8 +1885,7 @@
2360	1885	goto exit_release;
2361	1886
2362	1887	/* Read VID value */
2363		- if (sio_data->kind == w83667hg \|\| sio_data->kind == w83667hg_b \|\|
2364		- sio_data->kind == nct6775 \|\| sio_data->kind == nct6776) {
	1888	+ if (sio_data->kind == w83667hg \|\| sio_data->kind == w83667hg_b) {
2365	1889	/*
2366	1890	* W83667HG has different pins for VID input and output, so
2367	1891	* we can get the VID input values directly at logical device D
..	..	@@ -2369,11 +1893,7 @@
2369	1893	*/
2370	1894	superio_select(sio_data->sioreg, W83667HG_LD_VID);
2371	1895	data->vid = superio_inb(sio_data->sioreg, 0xe3);
2372		- err = device_create_file(dev, &dev_attr_cpu0_vid);
2373		- if (err) {
2374		- superio_exit(sio_data->sioreg);
2375		- goto exit_release;
2376		- }
	1896	+ data->have_vid = true;
2377	1897	} else if (sio_data->kind != w83627uhg) {
2378	1898	superio_select(sio_data->sioreg, W83627EHF_LD_HWM);
2379	1899	if (superio_inb(sio_data->sioreg, SIO_REG_VID_CTRL) & 0x80) {
..	..	@@ -2407,31 +1927,11 @@
2407	1927	SIO_REG_VID_DATA);
2408	1928	if (sio_data->kind == w83627ehf) /* 6 VID pins only */
2409	1929	data->vid &= 0x3f;
2410		-
2411		- err = device_create_file(dev, &dev_attr_cpu0_vid);
2412		- if (err) {
2413		- superio_exit(sio_data->sioreg);
2414		- goto exit_release;
2415		- }
	1930	+ data->have_vid = true;
2416	1931	} else {
2417	1932	dev_info(dev,
2418	1933	"VID pins in output mode, CPU VID not available\n");
2419	1934	}
2420		- }
2421		-
2422		- if (fan_debounce &&
2423		- (sio_data->kind == nct6775 \|\| sio_data->kind == nct6776)) {
2424		- u8 tmp;
2425		-
2426		- superio_select(sio_data->sioreg, W83627EHF_LD_HWM);
2427		- tmp = superio_inb(sio_data->sioreg, NCT6775_REG_FAN_DEBOUNCE);
2428		- if (sio_data->kind == nct6776)
2429		- superio_outb(sio_data->sioreg, NCT6775_REG_FAN_DEBOUNCE,
2430		- 0x3e \| tmp);
2431		- else
2432		- superio_outb(sio_data->sioreg, NCT6775_REG_FAN_DEBOUNCE,
2433		- 0x1e \| tmp);
2434		- pr_info("Enabled fan debounce for chip %s\n", data->name);
2435	1935	}
2436	1936
2437	1937	w83627ehf_check_fan_inputs(sio_data, data);
..	..	@@ -2439,158 +1939,25 @@
2439	1939	superio_exit(sio_data->sioreg);
2440	1940
2441	1941	/* Read fan clock dividers immediately */
2442		- w83627ehf_update_fan_div_common(dev, data);
	1942	+ w83627ehf_update_fan_div(data);
2443	1943
2444	1944	/* Read pwm data to save original values */
2445		- w83627ehf_update_pwm_common(dev, data);
	1945	+ w83627ehf_update_pwm(data);
2446	1946	for (i = 0; i < data->pwm_num; i++)
2447	1947	data->pwm_enable_orig[i] = data->pwm_enable[i];
2448	1948
2449		- /* Register sysfs hooks */
2450		- for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays); i++) {
2451		- err = device_create_file(dev, &sda_sf3_arrays[i].dev_attr);
2452		- if (err)
2453		- goto exit_remove;
2454		- }
2455		-
2456		- for (i = 0; i < ARRAY_SIZE(sda_sf3_max_step_arrays); i++) {
2457		- struct sensor_device_attribute *attr =
2458		- &sda_sf3_max_step_arrays[i];
2459		- if (data->REG_FAN_STEP_OUTPUT &&
2460		- data->REG_FAN_STEP_OUTPUT[attr->index] != 0xff) {
2461		- err = device_create_file(dev, &attr->dev_attr);
2462		- if (err)
2463		- goto exit_remove;
2464		- }
2465		- }
2466		- /* if fan3 and fan4 are enabled create the sf3 files for them */
2467		- if ((data->has_fan & (1 << 2)) && data->pwm_num >= 3)
2468		- for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays_fan3); i++) {
2469		- err = device_create_file(dev,
2470		- &sda_sf3_arrays_fan3[i].dev_attr);
2471		- if (err)
2472		- goto exit_remove;
2473		- }
2474		- if ((data->has_fan & (1 << 3)) && data->pwm_num >= 4)
2475		- for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays_fan4); i++) {
2476		- err = device_create_file(dev,
2477		- &sda_sf3_arrays_fan4[i].dev_attr);
2478		- if (err)
2479		- goto exit_remove;
2480		- }
2481		-
2482		- for (i = 0; i < data->in_num; i++) {
2483		- if ((i == 6) && data->in6_skip)
2484		- continue;
2485		- if ((err = device_create_file(dev, &sda_in_input[i].dev_attr))
2486		- \|\| (err = device_create_file(dev,
2487		- &sda_in_alarm[i].dev_attr))
2488		- \|\| (err = device_create_file(dev,
2489		- &sda_in_min[i].dev_attr))
2490		- \|\| (err = device_create_file(dev,
2491		- &sda_in_max[i].dev_attr)))
2492		- goto exit_remove;
2493		- }
2494		-
2495		- for (i = 0; i < 5; i++) {
2496		- if (data->has_fan & (1 << i)) {
2497		- if ((err = device_create_file(dev,
2498		- &sda_fan_input[i].dev_attr))
2499		- \|\| (err = device_create_file(dev,
2500		- &sda_fan_alarm[i].dev_attr)))
2501		- goto exit_remove;
2502		- if (sio_data->kind != nct6776) {
2503		- err = device_create_file(dev,
2504		- &sda_fan_div[i].dev_attr);
2505		- if (err)
2506		- goto exit_remove;
2507		- }
2508		- if (data->has_fan_min & (1 << i)) {
2509		- err = device_create_file(dev,
2510		- &sda_fan_min[i].dev_attr);
2511		- if (err)
2512		- goto exit_remove;
2513		- }
2514		- if (i < data->pwm_num &&
2515		- ((err = device_create_file(dev,
2516		- &sda_pwm[i].dev_attr))
2517		- \|\| (err = device_create_file(dev,
2518		- &sda_pwm_mode[i].dev_attr))
2519		- \|\| (err = device_create_file(dev,
2520		- &sda_pwm_enable[i].dev_attr))
2521		- \|\| (err = device_create_file(dev,
2522		- &sda_target_temp[i].dev_attr))
2523		- \|\| (err = device_create_file(dev,
2524		- &sda_tolerance[i].dev_attr))))
2525		- goto exit_remove;
2526		- }
2527		- }
2528		-
2529		- for (i = 0; i < NUM_REG_TEMP; i++) {
2530		- if (!(data->have_temp & (1 << i)))
2531		- continue;
2532		- err = device_create_file(dev, &sda_temp_input[i].dev_attr);
2533		- if (err)
2534		- goto exit_remove;
2535		- if (data->temp_label) {
2536		- err = device_create_file(dev,
2537		- &sda_temp_label[i].dev_attr);
2538		- if (err)
2539		- goto exit_remove;
2540		- }
2541		- if (i == 2 && data->temp3_val_only)
2542		- continue;
2543		- if (data->reg_temp_over[i]) {
2544		- err = device_create_file(dev,
2545		- &sda_temp_max[i].dev_attr);
2546		- if (err)
2547		- goto exit_remove;
2548		- }
2549		- if (data->reg_temp_hyst[i]) {
2550		- err = device_create_file(dev,
2551		- &sda_temp_max_hyst[i].dev_attr);
2552		- if (err)
2553		- goto exit_remove;
2554		- }
2555		- if (i > 2)
2556		- continue;
2557		- if ((err = device_create_file(dev,
2558		- &sda_temp_alarm[i].dev_attr))
2559		- \|\| (err = device_create_file(dev,
2560		- &sda_temp_type[i].dev_attr)))
2561		- goto exit_remove;
2562		- if (data->have_temp_offset & (1 << i)) {
2563		- err = device_create_file(dev,
2564		- &sda_temp_offset[i].dev_attr);
2565		- if (err)
2566		- goto exit_remove;
2567		- }
2568		- }
2569		-
2570		- err = device_create_file(dev, &sda_caseopen[0].dev_attr);
2571		- if (err)
2572		- goto exit_remove;
2573		-
2574		- if (sio_data->kind == nct6776) {
2575		- err = device_create_file(dev, &sda_caseopen[1].dev_attr);
2576		- if (err)
2577		- goto exit_remove;
2578		- }
2579		-
2580		- err = device_create_file(dev, &dev_attr_name);
2581		- if (err)
2582		- goto exit_remove;
2583		-
2584		- data->hwmon_dev = hwmon_device_register(dev);
2585		- if (IS_ERR(data->hwmon_dev)) {
2586		- err = PTR_ERR(data->hwmon_dev);
2587		- goto exit_remove;
	1949	+ hwmon_dev = devm_hwmon_device_register_with_info(&pdev->dev,
	1950	+ data->name,
	1951	+ data,
	1952	+ &w83627ehf_chip_info,
	1953	+ w83627ehf_groups);
	1954	+ if (IS_ERR(hwmon_dev)) {
	1955	+ err = PTR_ERR(hwmon_dev);
	1956	+ goto exit_release;
2588	1957	}
2589	1958
2590	1959	return 0;
2591	1960
2592		-exit_remove:
2593		- w83627ehf_device_remove_files(dev);
2594	1961	exit_release:
2595	1962	release_region(res->start, IOREGION_LENGTH);
2596	1963	exit:
..	..	@@ -2601,8 +1968,6 @@
2601	1968	{
2602	1969	struct w83627ehf_data *data = platform_get_drvdata(pdev);
2603	1970
2604		- hwmon_device_unregister(data->hwmon_dev);
2605		- w83627ehf_device_remove_files(&pdev->dev);
2606	1971	release_region(data->addr, IOREGION_LENGTH);
2607	1972
2608	1973	return 0;
..	..	@@ -2612,14 +1977,9 @@
2612	1977	static int w83627ehf_suspend(struct device *dev)
2613	1978	{
2614	1979	struct w83627ehf_data *data = w83627ehf_update_device(dev);
2615		- struct w83627ehf_sio_data *sio_data = dev_get_platdata(dev);
2616	1980
2617	1981	mutex_lock(&data->update_lock);
2618	1982	data->vbat = w83627ehf_read_value(data, W83627EHF_REG_VBAT);
2619		- if (sio_data->kind == nct6775) {
2620		- data->fandiv1 = w83627ehf_read_value(data, NCT6775_REG_FANDIV1);
2621		- data->fandiv2 = w83627ehf_read_value(data, NCT6775_REG_FANDIV2);
2622		- }
2623	1983	mutex_unlock(&data->update_lock);
2624	1984
2625	1985	return 0;
..	..	@@ -2628,7 +1988,6 @@
2628	1988	static int w83627ehf_resume(struct device *dev)
2629	1989	{
2630	1990	struct w83627ehf_data *data = dev_get_drvdata(dev);
2631		- struct w83627ehf_sio_data *sio_data = dev_get_platdata(dev);
2632	1991	int i;
2633	1992
2634	1993	mutex_lock(&data->update_lock);
..	..	@@ -2649,7 +2008,7 @@
2649	2008	if (!(data->has_fan_min & (1 << i)))
2650	2009	continue;
2651	2010
2652		- w83627ehf_write_value(data, data->REG_FAN_MIN[i],
	2011	+ w83627ehf_write_value(data, W83627EHF_REG_FAN_MIN[i],
2653	2012	data->fan_min[i]);
2654	2013	}
2655	2014
..	..	@@ -2673,10 +2032,6 @@
2673	2032
2674	2033	/* Restore other settings */
2675	2034	w83627ehf_write_value(data, W83627EHF_REG_VBAT, data->vbat);
2676		- if (sio_data->kind == nct6775) {
2677		- w83627ehf_write_value(data, NCT6775_REG_FANDIV1, data->fandiv1);
2678		- w83627ehf_write_value(data, NCT6775_REG_FANDIV2, data->fandiv2);
2679		- }
2680	2035
2681	2036	/* Force re-reading all values */
2682	2037	data->valid = 0;
..	..	@@ -2717,8 +2072,6 @@
2717	2072	static const char sio_name_W83627UHG[] __initconst = "W83627UHG";
2718	2073	static const char sio_name_W83667HG[] __initconst = "W83667HG";
2719	2074	static const char sio_name_W83667HG_B[] __initconst = "W83667HG-B";
2720		- static const char sio_name_NCT6775[] __initconst = "NCT6775F";
2721		- static const char sio_name_NCT6776[] __initconst = "NCT6776F";
2722	2075
2723	2076	u16 val;
2724	2077	const char *sio_name;
..	..	@@ -2761,14 +2114,6 @@
2761	2114	case SIO_W83667HG_B_ID:
2762	2115	sio_data->kind = w83667hg_b;
2763	2116	sio_name = sio_name_W83667HG_B;
2764		- break;
2765		- case SIO_NCT6775_ID:
2766		- sio_data->kind = nct6775;
2767		- sio_name = sio_name_NCT6775;
2768		- break;
2769		- case SIO_NCT6776_ID:
2770		- sio_data->kind = nct6776;
2771		- sio_name = sio_name_NCT6776;
2772	2117	break;
2773	2118	default:
2774	2119	if (val != 0xffff)