~hc/RK356X_SDK_RELEASE.git

..	..	@@ -1,3 +1,4 @@
	1	+// SPDX-License-Identifier: GPL-2.0-or-later
1	2	/*
2	3	* max6650.c - Part of lm_sensors, Linux kernel modules for hardware
3	4	* monitoring.
..	..	@@ -15,20 +16,6 @@
15	16	* The datasheet was last seen at:
16	17	*
17	18	* http://pdfserv.maxim-ic.com/en/ds/MAX6650-MAX6651.pdf
18		- *
19		- * This program is free software; you can redistribute it and/or modify
20		- * it under the terms of the GNU General Public License as published by
21		- * the Free Software Foundation; either version 2 of the License, or
22		- * (at your option) any later version.
23		- *
24		- * This program is distributed in the hope that it will be useful,
25		- * but WITHOUT ANY WARRANTY; without even the implied warranty of
26		- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
27		- * GNU General Public License for more details.
28		- *
29		- * You should have received a copy of the GNU General Public License
30		- * along with this program; if not, write to the Free Software
31		- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
32	19	*/
33	20
34	21	#include <linux/module.h>
..	..	@@ -40,6 +27,7 @@
40	27	#include <linux/hwmon-sysfs.h>
41	28	#include <linux/err.h>
42	29	#include <linux/of_device.h>
	30	+#include <linux/thermal.h>
43	31
44	32	/*
45	33	* Insmod parameters
..	..	@@ -52,9 +40,9 @@
52	40	/* clock: The clock frequency of the chip (max6651 can be clocked externally) */
53	41	static int clock = 254000;
54	42
55		-module_param(fan_voltage, int, S_IRUGO);
56		-module_param(prescaler, int, S_IRUGO);
57		-module_param(clock, int, S_IRUGO);
	43	+module_param(fan_voltage, int, 0444);
	44	+module_param(prescaler, int, 0444);
	45	+module_param(clock, int, 0444);
58	46
59	47	/*
60	48	* MAX 6650/6651 registers
..	..	@@ -104,7 +92,8 @@
104	92	#define FAN_RPM_MIN 240
105	93	#define FAN_RPM_MAX 30000
106	94
107		-#define DIV_FROM_REG(reg) (1 << (reg & 7))
	95	+#define DIV_FROM_REG(reg) (1 << ((reg) & 7))
	96	+#define DAC_LIMIT(v12) ((v12) ? 180 : 76)
108	97
109	98	/*
110	99	* Client data (each client gets its own)
..	..	@@ -112,10 +101,9 @@
112	101
113	102	struct max6650_data {
114	103	struct i2c_client *client;
115		- const struct attribute_group *groups[3];
116		- struct mutex update_lock;
	104	+ struct mutex update_lock; /* protect alarm register updates */
117	105	int nr_fans;
118		- char valid; /* zero until following fields are valid */
	106	+ bool valid; /* false until following fields are valid */
119	107	unsigned long last_updated; /* in jiffies */
120	108
121	109	/* register values */
..	..	@@ -125,6 +113,8 @@
125	113	u8 count;
126	114	u8 dac;
127	115	u8 alarm;
	116	+ u8 alarm_en;
	117	+ unsigned long cooling_dev_state;
128	118	};
129	119
130	120	static const u8 tach_reg[] = {
..	..	@@ -134,7 +124,7 @@
134	124	MAX6650_REG_TACH3,
135	125	};
136	126
137		-static const struct of_device_id max6650_dt_match[] = {
	127	+static const struct of_device_id __maybe_unused max6650_dt_match[] = {
138	128	{
139	129	.compatible = "maxim,max6650",
140	130	.data = (void *)1
..	..	@@ -147,41 +137,60 @@
147	137	};
148	138	MODULE_DEVICE_TABLE(of, max6650_dt_match);
149	139
	140	+static int dac_to_pwm(int dac, bool v12)
	141	+{
	142	+ /*
	143	+ * Useful range for dac is 0-180 for 12V fans and 0-76 for 5V fans.
	144	+ * Lower DAC values mean higher speeds.
	145	+ */
	146	+ return clamp_val(255 - (255 * dac) / DAC_LIMIT(v12), 0, 255);
	147	+}
	148	+
	149	+static u8 pwm_to_dac(unsigned int pwm, bool v12)
	150	+{
	151	+ int limit = DAC_LIMIT(v12);
	152	+
	153	+ return limit - (limit * pwm) / 255;
	154	+}
	155	+
150	156	static struct max6650_data max6650_update_device(struct device dev)
151	157	{
152	158	struct max6650_data *data = dev_get_drvdata(dev);
153	159	struct i2c_client *client = data->client;
	160	+ int reg, err = 0;
154	161	int i;
155	162
156	163	mutex_lock(&data->update_lock);
157	164
158	165	if (time_after(jiffies, data->last_updated + HZ) \|\| !data->valid) {
159		- data->speed = i2c_smbus_read_byte_data(client,
160		- MAX6650_REG_SPEED);
161		- data->config = i2c_smbus_read_byte_data(client,
162		- MAX6650_REG_CONFIG);
163	166	for (i = 0; i < data->nr_fans; i++) {
164		- data->tach[i] = i2c_smbus_read_byte_data(client,
165		- tach_reg[i]);
	167	+ reg = i2c_smbus_read_byte_data(client, tach_reg[i]);
	168	+ if (reg < 0) {
	169	+ err = reg;
	170	+ goto error;
	171	+ }
	172	+ data->tach[i] = reg;
166	173	}
167		- data->count = i2c_smbus_read_byte_data(client,
168		- MAX6650_REG_COUNT);
169		- data->dac = i2c_smbus_read_byte_data(client, MAX6650_REG_DAC);
170	174
171	175	/*
172	176	* Alarms are cleared on read in case the condition that
173	177	* caused the alarm is removed. Keep the value latched here
174	178	* for providing the register through different alarm files.
175	179	*/
176		- data->alarm \|= i2c_smbus_read_byte_data(client,
177		- MAX6650_REG_ALARM);
178		-
	180	+ reg = i2c_smbus_read_byte_data(client, MAX6650_REG_ALARM);
	181	+ if (reg < 0) {
	182	+ err = reg;
	183	+ goto error;
	184	+ }
	185	+ data->alarm \|= reg;
179	186	data->last_updated = jiffies;
180		- data->valid = 1;
	187	+ data->valid = true;
181	188	}
182	189
	190	+error:
183	191	mutex_unlock(&data->update_lock);
184		-
	192	+ if (err)
	193	+ data = ERR_PTR(err);
185	194	return data;
186	195	}
187	196
..	..	@@ -207,26 +216,6 @@
207	216	data->config = config;
208	217
209	218	return 0;
210		-}
211		-
212		-static ssize_t get_fan(struct device dev, struct device_attribute devattr,
213		- char *buf)
214		-{
215		- struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
216		- struct max6650_data *data = max6650_update_device(dev);
217		- int rpm;
218		-
219		- /*
220		- * Calculation details:
221		- *
222		- * Each tachometer counts over an interval given by the "count"
223		- * register (0.25, 0.5, 1 or 2 seconds). This module assumes
224		- * that the fans produce two pulses per revolution (this seems
225		- * to be the most common).
226		- */
227		-
228		- rpm = ((data->tach[attr->index] * 120) / DIV_FROM_REG(data->count));
229		- return sprintf(buf, "%d\n", rpm);
230	219	}
231	220
232	221	/*
..	..	@@ -270,26 +259,6 @@
270	259	* controlled.
271	260	*/
272	261
273		-static ssize_t fan1_target_show(struct device *dev,
274		- struct device_attribute devattr, char buf)
275		-{
276		- struct max6650_data *data = max6650_update_device(dev);
277		- int kscale, ktach, rpm;
278		-
279		- /*
280		- * Use the datasheet equation:
281		- *
282		- * FanSpeed = KSCALE x fCLK / [256 x (KTACH + 1)]
283		- *
284		- * then multiply by 60 to give rpm.
285		- */
286		-
287		- kscale = DIV_FROM_REG(data->config);
288		- ktach = data->speed;
289		- rpm = 60 * kscale * clock / (256 * (ktach + 1));
290		- return sprintf(buf, "%d\n", rpm);
291		-}
292		-
293	262	static int max6650_set_target(struct max6650_data *data, unsigned long rpm)
294	263	{
295	264	int kscale, ktach;
..	..	@@ -318,248 +287,42 @@
318	287	data->speed);
319	288	}
320	289
321		-static ssize_t fan1_target_store(struct device *dev,
322		- struct device_attribute *devattr,
323		- const char *buf, size_t count)
324		-{
325		- struct max6650_data *data = dev_get_drvdata(dev);
326		- unsigned long rpm;
327		- int err;
328		-
329		- err = kstrtoul(buf, 10, &rpm);
330		- if (err)
331		- return err;
332		-
333		- mutex_lock(&data->update_lock);
334		-
335		- err = max6650_set_target(data, rpm);
336		-
337		- mutex_unlock(&data->update_lock);
338		-
339		- if (err < 0)
340		- return err;
341		-
342		- return count;
343		-}
344		-
345	290	/*
346		- * Get/set the fan speed in open loop mode using pwm1 sysfs file.
347		- * Speed is given as a relative value from 0 to 255, where 255 is maximum
348		- * speed. Note that this is done by writing directly to the chip's DAC,
349		- * it won't change the closed loop speed set by fan1_target.
350		- * Also note that due to rounding errors it is possible that you don't read
351		- * back exactly the value you have set.
352		- */
353		-
354		-static ssize_t pwm1_show(struct device dev, struct device_attribute devattr,
355		- char *buf)
356		-{
357		- int pwm;
358		- struct max6650_data *data = max6650_update_device(dev);
359		-
360		- /*
361		- * Useful range for dac is 0-180 for 12V fans and 0-76 for 5V fans.
362		- * Lower DAC values mean higher speeds.
363		- */
364		- if (data->config & MAX6650_CFG_V12)
365		- pwm = 255 - (255 * (int)data->dac)/180;
366		- else
367		- pwm = 255 - (255 * (int)data->dac)/76;
368		-
369		- if (pwm < 0)
370		- pwm = 0;
371		-
372		- return sprintf(buf, "%d\n", pwm);
373		-}
374		-
375		-static ssize_t pwm1_store(struct device *dev,
376		- struct device_attribute devattr, const char buf,
377		- size_t count)
378		-{
379		- struct max6650_data *data = dev_get_drvdata(dev);
380		- struct i2c_client *client = data->client;
381		- unsigned long pwm;
382		- int err;
383		-
384		- err = kstrtoul(buf, 10, &pwm);
385		- if (err)
386		- return err;
387		-
388		- pwm = clamp_val(pwm, 0, 255);
389		-
390		- mutex_lock(&data->update_lock);
391		-
392		- if (data->config & MAX6650_CFG_V12)
393		- data->dac = 180 - (180 * pwm)/255;
394		- else
395		- data->dac = 76 - (76 * pwm)/255;
396		- err = i2c_smbus_write_byte_data(client, MAX6650_REG_DAC, data->dac);
397		-
398		- mutex_unlock(&data->update_lock);
399		-
400		- return err < 0 ? err : count;
401		-}
402		-
403		-/*
404		- * Get/Set controller mode:
405		- * Possible values:
406		- * 0 = Fan always on
407		- * 1 = Open loop, Voltage is set according to speed, not regulated.
408		- * 2 = Closed loop, RPM for all fans regulated by fan1 tachometer
409		- * 3 = Fan off
410		- */
411		-static ssize_t pwm1_enable_show(struct device *dev,
412		- struct device_attribute devattr, char buf)
413		-{
414		- struct max6650_data *data = max6650_update_device(dev);
415		- int mode = (data->config & MAX6650_CFG_MODE_MASK) >> 4;
416		- int sysfs_modes[4] = {0, 3, 2, 1};
417		-
418		- return sprintf(buf, "%d\n", sysfs_modes[mode]);
419		-}
420		-
421		-static ssize_t pwm1_enable_store(struct device *dev,
422		- struct device_attribute *devattr,
423		- const char *buf, size_t count)
424		-{
425		- struct max6650_data *data = dev_get_drvdata(dev);
426		- unsigned long mode;
427		- int err;
428		- const u8 max6650_modes[] = {
429		- MAX6650_CFG_MODE_ON,
430		- MAX6650_CFG_MODE_OPEN_LOOP,
431		- MAX6650_CFG_MODE_CLOSED_LOOP,
432		- MAX6650_CFG_MODE_OFF,
433		- };
434		-
435		- err = kstrtoul(buf, 10, &mode);
436		- if (err)
437		- return err;
438		-
439		- if (mode >= ARRAY_SIZE(max6650_modes))
440		- return -EINVAL;
441		-
442		- mutex_lock(&data->update_lock);
443		-
444		- max6650_set_operating_mode(data, max6650_modes[mode]);
445		-
446		- mutex_unlock(&data->update_lock);
447		-
448		- return count;
449		-}
450		-
451		-/*
452		- * Read/write functions for fan1_div sysfs file. The MAX6650 has no such
453		- * divider. We handle this by converting between divider and counttime:
454		- *
455		- * (counttime == k) <==> (divider == 2^k), k = 0, 1, 2, or 3
456		- *
457		- * Lower values of k allow to connect a faster fan without the risk of
458		- * counter overflow. The price is lower resolution. You can also set counttime
459		- * using the module parameter. Note that the module parameter "prescaler" also
460		- * influences the behaviour. Unfortunately, there's no sysfs attribute
461		- * defined for that. See the data sheet for details.
462		- */
463		-
464		-static ssize_t fan1_div_show(struct device *dev,
465		- struct device_attribute devattr, char buf)
466		-{
467		- struct max6650_data *data = max6650_update_device(dev);
468		-
469		- return sprintf(buf, "%d\n", DIV_FROM_REG(data->count));
470		-}
471		-
472		-static ssize_t fan1_div_store(struct device *dev,
473		- struct device_attribute *devattr,
474		- const char *buf, size_t count)
475		-{
476		- struct max6650_data *data = dev_get_drvdata(dev);
477		- struct i2c_client *client = data->client;
478		- unsigned long div;
479		- int err;
480		-
481		- err = kstrtoul(buf, 10, &div);
482		- if (err)
483		- return err;
484		-
485		- mutex_lock(&data->update_lock);
486		- switch (div) {
487		- case 1:
488		- data->count = 0;
489		- break;
490		- case 2:
491		- data->count = 1;
492		- break;
493		- case 4:
494		- data->count = 2;
495		- break;
496		- case 8:
497		- data->count = 3;
498		- break;
499		- default:
500		- mutex_unlock(&data->update_lock);
501		- return -EINVAL;
502		- }
503		-
504		- i2c_smbus_write_byte_data(client, MAX6650_REG_COUNT, data->count);
505		- mutex_unlock(&data->update_lock);
506		-
507		- return count;
508		-}
509		-
510		-/*
511		- * Get alarm stati:
	291	+ * Get gpio alarm status:
512	292	* Possible values:
513	293	* 0 = no alarm
514	294	* 1 = alarm
515	295	*/
516	296
517		-static ssize_t get_alarm(struct device dev, struct device_attribute devattr,
518		- char *buf)
	297	+static ssize_t alarm_show(struct device *dev,
	298	+ struct device_attribute devattr, char buf)
519	299	{
520	300	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
521	301	struct max6650_data *data = max6650_update_device(dev);
522		- struct i2c_client *client = data->client;
523		- int alarm = 0;
	302	+ bool alarm;
524	303
525		- if (data->alarm & attr->index) {
	304	+ if (IS_ERR(data))
	305	+ return PTR_ERR(data);
	306	+
	307	+ alarm = data->alarm & attr->index;
	308	+ if (alarm) {
526	309	mutex_lock(&data->update_lock);
527		- alarm = 1;
528	310	data->alarm &= ~attr->index;
529		- data->alarm \|= i2c_smbus_read_byte_data(client,
530		- MAX6650_REG_ALARM);
	311	+ data->valid = false;
531	312	mutex_unlock(&data->update_lock);
532	313	}
533	314
534	315	return sprintf(buf, "%d\n", alarm);
535	316	}
536	317
537		-static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, get_fan, NULL, 0);
538		-static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, get_fan, NULL, 1);
539		-static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, get_fan, NULL, 2);
540		-static SENSOR_DEVICE_ATTR(fan4_input, S_IRUGO, get_fan, NULL, 3);
541		-static DEVICE_ATTR_RW(fan1_target);
542		-static DEVICE_ATTR_RW(fan1_div);
543		-static DEVICE_ATTR_RW(pwm1_enable);
544		-static DEVICE_ATTR_RW(pwm1);
545		-static SENSOR_DEVICE_ATTR(fan1_max_alarm, S_IRUGO, get_alarm, NULL,
546		- MAX6650_ALRM_MAX);
547		-static SENSOR_DEVICE_ATTR(fan1_min_alarm, S_IRUGO, get_alarm, NULL,
548		- MAX6650_ALRM_MIN);
549		-static SENSOR_DEVICE_ATTR(fan1_fault, S_IRUGO, get_alarm, NULL,
550		- MAX6650_ALRM_TACH);
551		-static SENSOR_DEVICE_ATTR(gpio1_alarm, S_IRUGO, get_alarm, NULL,
552		- MAX6650_ALRM_GPIO1);
553		-static SENSOR_DEVICE_ATTR(gpio2_alarm, S_IRUGO, get_alarm, NULL,
554		- MAX6650_ALRM_GPIO2);
	318	+static SENSOR_DEVICE_ATTR_RO(gpio1_alarm, alarm, MAX6650_ALRM_GPIO1);
	319	+static SENSOR_DEVICE_ATTR_RO(gpio2_alarm, alarm, MAX6650_ALRM_GPIO2);
555	320
556	321	static umode_t max6650_attrs_visible(struct kobject kobj, struct attribute a,
557		- int n)
	322	+ int n)
558	323	{
559	324	struct device *dev = container_of(kobj, struct device, kobj);
560	325	struct max6650_data *data = dev_get_drvdata(dev);
561		- struct i2c_client *client = data->client;
562		- u8 alarm_en = i2c_smbus_read_byte_data(client, MAX6650_REG_ALARM_EN);
563	326	struct device_attribute *devattr;
564	327
565	328	/*
..	..	@@ -567,12 +330,9 @@
567	330	*/
568	331
569	332	devattr = container_of(a, struct device_attribute, attr);
570		- if (devattr == &sensor_dev_attr_fan1_max_alarm.dev_attr
571		- \|\| devattr == &sensor_dev_attr_fan1_min_alarm.dev_attr
572		- \|\| devattr == &sensor_dev_attr_fan1_fault.dev_attr
573		- \|\| devattr == &sensor_dev_attr_gpio1_alarm.dev_attr
574		- \|\| devattr == &sensor_dev_attr_gpio2_alarm.dev_attr) {
575		- if (!(alarm_en & to_sensor_dev_attr(devattr)->index))
	333	+ if (devattr == &sensor_dev_attr_gpio1_alarm.dev_attr \|\|
	334	+ devattr == &sensor_dev_attr_gpio2_alarm.dev_attr) {
	335	+ if (!(data->alarm_en & to_sensor_dev_attr(devattr)->index))
576	336	return 0;
577	337	}
578	338
..	..	@@ -580,14 +340,6 @@
580	340	}
581	341
582	342	static struct attribute *max6650_attrs[] = {
583		- &sensor_dev_attr_fan1_input.dev_attr.attr,
584		- &dev_attr_fan1_target.attr,
585		- &dev_attr_fan1_div.attr,
586		- &dev_attr_pwm1_enable.attr,
587		- &dev_attr_pwm1.attr,
588		- &sensor_dev_attr_fan1_max_alarm.dev_attr.attr,
589		- &sensor_dev_attr_fan1_min_alarm.dev_attr.attr,
590		- &sensor_dev_attr_fan1_fault.dev_attr.attr,
591	343	&sensor_dev_attr_gpio1_alarm.dev_attr.attr,
592	344	&sensor_dev_attr_gpio2_alarm.dev_attr.attr,
593	345	NULL
..	..	@@ -598,27 +350,17 @@
598	350	.is_visible = max6650_attrs_visible,
599	351	};
600	352
601		-static struct attribute *max6651_attrs[] = {
602		- &sensor_dev_attr_fan2_input.dev_attr.attr,
603		- &sensor_dev_attr_fan3_input.dev_attr.attr,
604		- &sensor_dev_attr_fan4_input.dev_attr.attr,
	353	+static const struct attribute_group *max6650_groups[] = {
	354	+ &max6650_group,
605	355	NULL
606	356	};
607		-
608		-static const struct attribute_group max6651_group = {
609		- .attrs = max6651_attrs,
610		-};
611		-
612		-/*
613		- * Real code
614		- */
615	357
616	358	static int max6650_init_client(struct max6650_data *data,
617	359	struct i2c_client *client)
618	360	{
619	361	struct device *dev = &client->dev;
620		- int config;
621		- int err = -EIO;
	362	+ int reg;
	363	+ int err;
622	364	u32 voltage;
623	365	u32 prescale;
624	366	u32 target_rpm;
..	..	@@ -632,21 +374,20 @@
632	374	&prescale))
633	375	prescale = prescaler;
634	376
635		- config = i2c_smbus_read_byte_data(client, MAX6650_REG_CONFIG);
636		-
637		- if (config < 0) {
638		- dev_err(dev, "Error reading config, aborting.\n");
639		- return err;
	377	+ reg = i2c_smbus_read_byte_data(client, MAX6650_REG_CONFIG);
	378	+ if (reg < 0) {
	379	+ dev_err(dev, "Error reading config register, aborting.\n");
	380	+ return reg;
640	381	}
641	382
642	383	switch (voltage) {
643	384	case 0:
644	385	break;
645	386	case 5:
646		- config &= ~MAX6650_CFG_V12;
	387	+ reg &= ~MAX6650_CFG_V12;
647	388	break;
648	389	case 12:
649		- config \|= MAX6650_CFG_V12;
	390	+ reg \|= MAX6650_CFG_V12;
650	391	break;
651	392	default:
652	393	dev_err(dev, "illegal value for fan_voltage (%d)\n", voltage);
..	..	@@ -656,22 +397,22 @@
656	397	case 0:
657	398	break;
658	399	case 1:
659		- config &= ~MAX6650_CFG_PRESCALER_MASK;
	400	+ reg &= ~MAX6650_CFG_PRESCALER_MASK;
660	401	break;
661	402	case 2:
662		- config = (config & ~MAX6650_CFG_PRESCALER_MASK)
	403	+ reg = (reg & ~MAX6650_CFG_PRESCALER_MASK)
663	404	\| MAX6650_CFG_PRESCALER_2;
664	405	break;
665	406	case 4:
666		- config = (config & ~MAX6650_CFG_PRESCALER_MASK)
	407	+ reg = (reg & ~MAX6650_CFG_PRESCALER_MASK)
667	408	\| MAX6650_CFG_PRESCALER_4;
668	409	break;
669	410	case 8:
670		- config = (config & ~MAX6650_CFG_PRESCALER_MASK)
	411	+ reg = (reg & ~MAX6650_CFG_PRESCALER_MASK)
671	412	\| MAX6650_CFG_PRESCALER_8;
672	413	break;
673	414	case 16:
674		- config = (config & ~MAX6650_CFG_PRESCALER_MASK)
	415	+ reg = (reg & ~MAX6650_CFG_PRESCALER_MASK)
675	416	\| MAX6650_CFG_PRESCALER_16;
676	417	break;
677	418	default:
..	..	@@ -679,16 +420,43 @@
679	420	}
680	421
681	422	dev_info(dev, "Fan voltage: %dV, prescaler: %d.\n",
682		- (config & MAX6650_CFG_V12) ? 12 : 5,
683		- 1 << (config & MAX6650_CFG_PRESCALER_MASK));
	423	+ (reg & MAX6650_CFG_V12) ? 12 : 5,
	424	+ 1 << (reg & MAX6650_CFG_PRESCALER_MASK));
684	425
685		- if (i2c_smbus_write_byte_data(client, MAX6650_REG_CONFIG, config)) {
	426	+ err = i2c_smbus_write_byte_data(client, MAX6650_REG_CONFIG, reg);
	427	+ if (err) {
686	428	dev_err(dev, "Config write error, aborting.\n");
687	429	return err;
688	430	}
	431	+ data->config = reg;
689	432
690		- data->config = config;
691		- data->count = i2c_smbus_read_byte_data(client, MAX6650_REG_COUNT);
	433	+ reg = i2c_smbus_read_byte_data(client, MAX6650_REG_SPEED);
	434	+ if (reg < 0) {
	435	+ dev_err(dev, "Failed to read speed register, aborting.\n");
	436	+ return reg;
	437	+ }
	438	+ data->speed = reg;
	439	+
	440	+ reg = i2c_smbus_read_byte_data(client, MAX6650_REG_DAC);
	441	+ if (reg < 0) {
	442	+ dev_err(dev, "Failed to read DAC register, aborting.\n");
	443	+ return reg;
	444	+ }
	445	+ data->dac = reg;
	446	+
	447	+ reg = i2c_smbus_read_byte_data(client, MAX6650_REG_COUNT);
	448	+ if (reg < 0) {
	449	+ dev_err(dev, "Failed to read count register, aborting.\n");
	450	+ return reg;
	451	+ }
	452	+ data->count = reg;
	453	+
	454	+ reg = i2c_smbus_read_byte_data(client, MAX6650_REG_ALARM_EN);
	455	+ if (reg < 0) {
	456	+ dev_err(dev, "Failed to read alarm configuration, aborting.\n");
	457	+ return reg;
	458	+ }
	459	+ data->alarm_en = reg;
692	460
693	461	if (!of_property_read_u32(client->dev.of_node, "maxim,fan-target-rpm",
694	462	&target_rpm)) {
..	..	@@ -699,9 +467,301 @@
699	467	return 0;
700	468	}
701	469
702		-static int max6650_probe(struct i2c_client *client,
703		- const struct i2c_device_id *id)
	470	+static int max6650_get_max_state(struct thermal_cooling_device *cdev,
	471	+ unsigned long *state)
704	472	{
	473	+ *state = 255;
	474	+
	475	+ return 0;
	476	+}
	477	+
	478	+static int max6650_get_cur_state(struct thermal_cooling_device *cdev,
	479	+ unsigned long *state)
	480	+{
	481	+ struct max6650_data *data = cdev->devdata;
	482	+
	483	+ *state = data->cooling_dev_state;
	484	+
	485	+ return 0;
	486	+}
	487	+
	488	+static int max6650_set_cur_state(struct thermal_cooling_device *cdev,
	489	+ unsigned long state)
	490	+{
	491	+ struct max6650_data *data = cdev->devdata;
	492	+ struct i2c_client *client = data->client;
	493	+ int err;
	494	+
	495	+ state = clamp_val(state, 0, 255);
	496	+
	497	+ mutex_lock(&data->update_lock);
	498	+
	499	+ data->dac = pwm_to_dac(state, data->config & MAX6650_CFG_V12);
	500	+ err = i2c_smbus_write_byte_data(client, MAX6650_REG_DAC, data->dac);
	501	+ if (!err) {
	502	+ max6650_set_operating_mode(data, state ?
	503	+ MAX6650_CFG_MODE_OPEN_LOOP :
	504	+ MAX6650_CFG_MODE_OFF);
	505	+ data->cooling_dev_state = state;
	506	+ }
	507	+
	508	+ mutex_unlock(&data->update_lock);
	509	+
	510	+ return err;
	511	+}
	512	+
	513	+static const struct thermal_cooling_device_ops max6650_cooling_ops = {
	514	+ .get_max_state = max6650_get_max_state,
	515	+ .get_cur_state = max6650_get_cur_state,
	516	+ .set_cur_state = max6650_set_cur_state,
	517	+};
	518	+
	519	+static int max6650_read(struct device *dev, enum hwmon_sensor_types type,
	520	+ u32 attr, int channel, long *val)
	521	+{
	522	+ struct max6650_data *data = max6650_update_device(dev);
	523	+ int mode;
	524	+
	525	+ if (IS_ERR(data))
	526	+ return PTR_ERR(data);
	527	+
	528	+ switch (type) {
	529	+ case hwmon_pwm:
	530	+ switch (attr) {
	531	+ case hwmon_pwm_input:
	532	+ *val = dac_to_pwm(data->dac,
	533	+ data->config & MAX6650_CFG_V12);
	534	+ break;
	535	+ case hwmon_pwm_enable:
	536	+ /*
	537	+ * Possible values:
	538	+ * 0 = Fan always on
	539	+ * 1 = Open loop, Voltage is set according to speed,
	540	+ * not regulated.
	541	+ * 2 = Closed loop, RPM for all fans regulated by fan1
	542	+ * tachometer
	543	+ * 3 = Fan off
	544	+ */
	545	+ mode = (data->config & MAX6650_CFG_MODE_MASK) >> 4;
	546	+ val = (4 - mode) & 3; / {0 1 2 3} -> {0 3 2 1} */
	547	+ break;
	548	+ default:
	549	+ return -EOPNOTSUPP;
	550	+ }
	551	+ break;
	552	+ case hwmon_fan:
	553	+ switch (attr) {
	554	+ case hwmon_fan_input:
	555	+ /*
	556	+ * Calculation details:
	557	+ *
	558	+ * Each tachometer counts over an interval given by the
	559	+ * "count" register (0.25, 0.5, 1 or 2 seconds).
	560	+ * The driver assumes that the fans produce two pulses
	561	+ * per revolution (this seems to be the most common).
	562	+ */
	563	+ val = DIV_ROUND_CLOSEST(data->tach[channel] 120,
	564	+ DIV_FROM_REG(data->count));
	565	+ break;
	566	+ case hwmon_fan_div:
	567	+ *val = DIV_FROM_REG(data->count);
	568	+ break;
	569	+ case hwmon_fan_target:
	570	+ /*
	571	+ * Use the datasheet equation:
	572	+ * FanSpeed = KSCALE x fCLK / [256 x (KTACH + 1)]
	573	+ * then multiply by 60 to give rpm.
	574	+ */
	575	+ val = 60 DIV_FROM_REG(data->config) * clock /
	576	+ (256 * (data->speed + 1));
	577	+ break;
	578	+ case hwmon_fan_min_alarm:
	579	+ *val = !!(data->alarm & MAX6650_ALRM_MIN);
	580	+ data->alarm &= ~MAX6650_ALRM_MIN;
	581	+ data->valid = false;
	582	+ break;
	583	+ case hwmon_fan_max_alarm:
	584	+ *val = !!(data->alarm & MAX6650_ALRM_MAX);
	585	+ data->alarm &= ~MAX6650_ALRM_MAX;
	586	+ data->valid = false;
	587	+ break;
	588	+ case hwmon_fan_fault:
	589	+ *val = !!(data->alarm & MAX6650_ALRM_TACH);
	590	+ data->alarm &= ~MAX6650_ALRM_TACH;
	591	+ data->valid = false;
	592	+ break;
	593	+ default:
	594	+ return -EOPNOTSUPP;
	595	+ }
	596	+ break;
	597	+ default:
	598	+ return -EOPNOTSUPP;
	599	+ }
	600	+ return 0;
	601	+}
	602	+
	603	+static const u8 max6650_pwm_modes[] = {
	604	+ MAX6650_CFG_MODE_ON,
	605	+ MAX6650_CFG_MODE_OPEN_LOOP,
	606	+ MAX6650_CFG_MODE_CLOSED_LOOP,
	607	+ MAX6650_CFG_MODE_OFF,
	608	+};
	609	+
	610	+static int max6650_write(struct device *dev, enum hwmon_sensor_types type,
	611	+ u32 attr, int channel, long val)
	612	+{
	613	+ struct max6650_data *data = dev_get_drvdata(dev);
	614	+ int ret = 0;
	615	+ u8 reg;
	616	+
	617	+ mutex_lock(&data->update_lock);
	618	+
	619	+ switch (type) {
	620	+ case hwmon_pwm:
	621	+ switch (attr) {
	622	+ case hwmon_pwm_input:
	623	+ reg = pwm_to_dac(clamp_val(val, 0, 255),
	624	+ data->config & MAX6650_CFG_V12);
	625	+ ret = i2c_smbus_write_byte_data(data->client,
	626	+ MAX6650_REG_DAC, reg);
	627	+ if (ret)
	628	+ break;
	629	+ data->dac = reg;
	630	+ break;
	631	+ case hwmon_pwm_enable:
	632	+ if (val < 0 \|\| val >= ARRAY_SIZE(max6650_pwm_modes)) {
	633	+ ret = -EINVAL;
	634	+ break;
	635	+ }
	636	+ ret = max6650_set_operating_mode(data,
	637	+ max6650_pwm_modes[val]);
	638	+ break;
	639	+ default:
	640	+ ret = -EOPNOTSUPP;
	641	+ break;
	642	+ }
	643	+ break;
	644	+ case hwmon_fan:
	645	+ switch (attr) {
	646	+ case hwmon_fan_div:
	647	+ switch (val) {
	648	+ case 1:
	649	+ reg = 0;
	650	+ break;
	651	+ case 2:
	652	+ reg = 1;
	653	+ break;
	654	+ case 4:
	655	+ reg = 2;
	656	+ break;
	657	+ case 8:
	658	+ reg = 3;
	659	+ break;
	660	+ default:
	661	+ ret = -EINVAL;
	662	+ goto error;
	663	+ }
	664	+ ret = i2c_smbus_write_byte_data(data->client,
	665	+ MAX6650_REG_COUNT, reg);
	666	+ if (ret)
	667	+ break;
	668	+ data->count = reg;
	669	+ break;
	670	+ case hwmon_fan_target:
	671	+ if (val < 0) {
	672	+ ret = -EINVAL;
	673	+ break;
	674	+ }
	675	+ ret = max6650_set_target(data, val);
	676	+ break;
	677	+ default:
	678	+ ret = -EOPNOTSUPP;
	679	+ break;
	680	+ }
	681	+ break;
	682	+ default:
	683	+ ret = -EOPNOTSUPP;
	684	+ break;
	685	+ }
	686	+
	687	+error:
	688	+ mutex_unlock(&data->update_lock);
	689	+ return ret;
	690	+}
	691	+
	692	+static umode_t max6650_is_visible(const void *_data,
	693	+ enum hwmon_sensor_types type, u32 attr,
	694	+ int channel)
	695	+{
	696	+ const struct max6650_data *data = _data;
	697	+
	698	+ if (channel && (channel >= data->nr_fans \|\| type != hwmon_fan))
	699	+ return 0;
	700	+
	701	+ switch (type) {
	702	+ case hwmon_fan:
	703	+ switch (attr) {
	704	+ case hwmon_fan_input:
	705	+ return 0444;
	706	+ case hwmon_fan_target:
	707	+ case hwmon_fan_div:
	708	+ return 0644;
	709	+ case hwmon_fan_min_alarm:
	710	+ if (data->alarm_en & MAX6650_ALRM_MIN)
	711	+ return 0444;
	712	+ break;
	713	+ case hwmon_fan_max_alarm:
	714	+ if (data->alarm_en & MAX6650_ALRM_MAX)
	715	+ return 0444;
	716	+ break;
	717	+ case hwmon_fan_fault:
	718	+ if (data->alarm_en & MAX6650_ALRM_TACH)
	719	+ return 0444;
	720	+ break;
	721	+ default:
	722	+ break;
	723	+ }
	724	+ break;
	725	+ case hwmon_pwm:
	726	+ switch (attr) {
	727	+ case hwmon_pwm_input:
	728	+ case hwmon_pwm_enable:
	729	+ return 0644;
	730	+ default:
	731	+ break;
	732	+ }
	733	+ break;
	734	+ default:
	735	+ break;
	736	+ }
	737	+ return 0;
	738	+}
	739	+
	740	+static const struct hwmon_channel_info *max6650_info[] = {
	741	+ HWMON_CHANNEL_INFO(fan, HWMON_F_INPUT \| HWMON_F_TARGET \| HWMON_F_DIV \|
	742	+ HWMON_F_MIN_ALARM \| HWMON_F_MAX_ALARM \|
	743	+ HWMON_F_FAULT,
	744	+ HWMON_F_INPUT, HWMON_F_INPUT, HWMON_F_INPUT),
	745	+ HWMON_CHANNEL_INFO(pwm, HWMON_PWM_INPUT \| HWMON_PWM_ENABLE),
	746	+ NULL
	747	+};
	748	+
	749	+static const struct hwmon_ops max6650_hwmon_ops = {
	750	+ .read = max6650_read,
	751	+ .write = max6650_write,
	752	+ .is_visible = max6650_is_visible,
	753	+};
	754	+
	755	+static const struct hwmon_chip_info max6650_chip_info = {
	756	+ .ops = &max6650_hwmon_ops,
	757	+ .info = max6650_info,
	758	+};
	759	+
	760	+static const struct i2c_device_id max6650_id[];
	761	+
	762	+static int max6650_probe(struct i2c_client *client)
	763	+{
	764	+ struct thermal_cooling_device *cooling_dev;
705	765	struct device *dev = &client->dev;
706	766	const struct of_device_id *of_id =
707	767	of_match_device(of_match_ptr(max6650_dt_match), dev);
..	..	@@ -714,8 +774,10 @@
714	774	return -ENOMEM;
715	775
716	776	data->client = client;
	777	+ i2c_set_clientdata(client, data);
717	778	mutex_init(&data->update_lock);
718		- data->nr_fans = of_id ? (int)(uintptr_t)of_id->data : id->driver_data;
	779	+ data->nr_fans = of_id ? (int)(uintptr_t)of_id->data :
	780	+ i2c_match_id(max6650_id, client)->driver_data;
719	781
720	782	/*
721	783	* Initialize the max6650 chip
..	..	@@ -724,15 +786,25 @@
724	786	if (err)
725	787	return err;
726	788
727		- data->groups[0] = &max6650_group;
728		- /* 3 additional fan inputs for the MAX6651 */
729		- if (data->nr_fans == 4)
730		- data->groups[1] = &max6651_group;
	789	+ hwmon_dev = devm_hwmon_device_register_with_info(dev,
	790	+ client->name, data,
	791	+ &max6650_chip_info,
	792	+ max6650_groups);
	793	+ err = PTR_ERR_OR_ZERO(hwmon_dev);
	794	+ if (err)
	795	+ return err;
731	796
732		- hwmon_dev = devm_hwmon_device_register_with_groups(dev,
733		- client->name, data,
734		- data->groups);
735		- return PTR_ERR_OR_ZERO(hwmon_dev);
	797	+ if (IS_ENABLED(CONFIG_THERMAL)) {
	798	+ cooling_dev = devm_thermal_of_cooling_device_register(dev,
	799	+ dev->of_node, client->name,
	800	+ data, &max6650_cooling_ops);
	801	+ if (IS_ERR(cooling_dev)) {
	802	+ dev_warn(dev, "thermal cooling device register failed: %ld\n",
	803	+ PTR_ERR(cooling_dev));
	804	+ }
	805	+ }
	806	+
	807	+ return 0;
736	808	}
737	809
738	810	static const struct i2c_device_id max6650_id[] = {
..	..	@@ -747,7 +819,7 @@
747	819	.name = "max6650",
748	820	.of_match_table = of_match_ptr(max6650_dt_match),
749	821	},
750		- .probe = max6650_probe,
	822	+ .probe_new = max6650_probe,
751	823	.id_table = max6650_id,
752	824	};
753	825