1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * max6650.c - Part of lm_sensors, Linux kernel modules for hardware
6 * (C) 2007 by Hans J. Koch <hjk@hansjkoch.de>
8 * based on code written by John Morris <john.morris@spirentcom.com>
9 * Copyright (c) 2003 Spirent Communications
10 * and Claus Gindhart <claus.gindhart@kontron.com>
12 * This module has only been tested with the MAX6650 chip. It should
13 * also work with the MAX6651. It does not distinguish max6650 and max6651
16 * The datasheet was last seen at:
18 * http://pdfserv.maxim-ic.com/en/ds/MAX6650-MAX6651.pdf
21 #include <linux/module.h>
22 #include <linux/init.h>
23 #include <linux/slab.h>
24 #include <linux/jiffies.h>
25 #include <linux/i2c.h>
26 #include <linux/hwmon.h>
27 #include <linux/hwmon-sysfs.h>
28 #include <linux/err.h>
29 #include <linux/of_device.h>
30 #include <linux/thermal.h>
36 /* fan_voltage: 5=5V fan, 12=12V fan, 0=don't change */
37 static int fan_voltage
;
38 /* prescaler: Possible values are 1, 2, 4, 8, 16 or 0 for don't change */
40 /* clock: The clock frequency of the chip (max6651 can be clocked externally) */
41 static int clock
= 254000;
43 module_param(fan_voltage
, int, 0444);
44 module_param(prescaler
, int, 0444);
45 module_param(clock
, int, 0444);
48 * MAX 6650/6651 registers
51 #define MAX6650_REG_SPEED 0x00
52 #define MAX6650_REG_CONFIG 0x02
53 #define MAX6650_REG_GPIO_DEF 0x04
54 #define MAX6650_REG_DAC 0x06
55 #define MAX6650_REG_ALARM_EN 0x08
56 #define MAX6650_REG_ALARM 0x0A
57 #define MAX6650_REG_TACH0 0x0C
58 #define MAX6650_REG_TACH1 0x0E
59 #define MAX6650_REG_TACH2 0x10
60 #define MAX6650_REG_TACH3 0x12
61 #define MAX6650_REG_GPIO_STAT 0x14
62 #define MAX6650_REG_COUNT 0x16
65 * Config register bits
68 #define MAX6650_CFG_V12 0x08
69 #define MAX6650_CFG_PRESCALER_MASK 0x07
70 #define MAX6650_CFG_PRESCALER_2 0x01
71 #define MAX6650_CFG_PRESCALER_4 0x02
72 #define MAX6650_CFG_PRESCALER_8 0x03
73 #define MAX6650_CFG_PRESCALER_16 0x04
74 #define MAX6650_CFG_MODE_MASK 0x30
75 #define MAX6650_CFG_MODE_ON 0x00
76 #define MAX6650_CFG_MODE_OFF 0x10
77 #define MAX6650_CFG_MODE_CLOSED_LOOP 0x20
78 #define MAX6650_CFG_MODE_OPEN_LOOP 0x30
79 #define MAX6650_COUNT_MASK 0x03
82 * Alarm status register bits
85 #define MAX6650_ALRM_MAX 0x01
86 #define MAX6650_ALRM_MIN 0x02
87 #define MAX6650_ALRM_TACH 0x04
88 #define MAX6650_ALRM_GPIO1 0x08
89 #define MAX6650_ALRM_GPIO2 0x10
91 /* Minimum and maximum values of the FAN-RPM */
92 #define FAN_RPM_MIN 240
93 #define FAN_RPM_MAX 30000
95 #define DIV_FROM_REG(reg) (1 << (reg & 7))
98 * Client data (each client gets its own)
101 struct max6650_data
{
102 struct i2c_client
*client
;
103 const struct attribute_group
*groups
[3];
104 struct thermal_cooling_device
*cooling_dev
;
105 struct mutex update_lock
;
107 char valid
; /* zero until following fields are valid */
108 unsigned long last_updated
; /* in jiffies */
110 /* register values */
117 unsigned long cooling_dev_state
;
120 static const u8 tach_reg
[] = {
127 static const struct of_device_id __maybe_unused max6650_dt_match
[] = {
129 .compatible
= "maxim,max6650",
133 .compatible
= "maxim,max6651",
138 MODULE_DEVICE_TABLE(of
, max6650_dt_match
);
140 static struct max6650_data
*max6650_update_device(struct device
*dev
)
142 struct max6650_data
*data
= dev_get_drvdata(dev
);
143 struct i2c_client
*client
= data
->client
;
146 mutex_lock(&data
->update_lock
);
148 if (time_after(jiffies
, data
->last_updated
+ HZ
) || !data
->valid
) {
149 data
->speed
= i2c_smbus_read_byte_data(client
,
151 data
->config
= i2c_smbus_read_byte_data(client
,
153 for (i
= 0; i
< data
->nr_fans
; i
++) {
154 data
->tach
[i
] = i2c_smbus_read_byte_data(client
,
157 data
->count
= i2c_smbus_read_byte_data(client
,
159 data
->dac
= i2c_smbus_read_byte_data(client
, MAX6650_REG_DAC
);
162 * Alarms are cleared on read in case the condition that
163 * caused the alarm is removed. Keep the value latched here
164 * for providing the register through different alarm files.
166 data
->alarm
|= i2c_smbus_read_byte_data(client
,
169 data
->last_updated
= jiffies
;
173 mutex_unlock(&data
->update_lock
);
179 * Change the operating mode of the chip (if needed).
180 * mode is one of the MAX6650_CFG_MODE_* values.
182 static int max6650_set_operating_mode(struct max6650_data
*data
, u8 mode
)
185 u8 config
= data
->config
;
187 if (mode
== (config
& MAX6650_CFG_MODE_MASK
))
190 config
= (config
& ~MAX6650_CFG_MODE_MASK
) | mode
;
192 result
= i2c_smbus_write_byte_data(data
->client
, MAX6650_REG_CONFIG
,
197 data
->config
= config
;
202 static ssize_t
fan_show(struct device
*dev
, struct device_attribute
*devattr
,
205 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
206 struct max6650_data
*data
= max6650_update_device(dev
);
210 * Calculation details:
212 * Each tachometer counts over an interval given by the "count"
213 * register (0.25, 0.5, 1 or 2 seconds). This module assumes
214 * that the fans produce two pulses per revolution (this seems
215 * to be the most common).
218 rpm
= ((data
->tach
[attr
->index
] * 120) / DIV_FROM_REG(data
->count
));
219 return sprintf(buf
, "%d\n", rpm
);
223 * Set the fan speed to the specified RPM (or read back the RPM setting).
224 * This works in closed loop mode only. Use pwm1 for open loop speed setting.
226 * The MAX6650/1 will automatically control fan speed when in closed loop
231 * 1) The MAX6650/1 internal 254kHz clock frequency is set correctly. Use
232 * the clock module parameter if you need to fine tune this.
234 * 2) The prescaler (low three bits of the config register) has already
235 * been set to an appropriate value. Use the prescaler module parameter
236 * if your BIOS doesn't initialize the chip properly.
238 * The relevant equations are given on pages 21 and 22 of the datasheet.
240 * From the datasheet, the relevant equation when in regulation is:
242 * [fCLK / (128 x (KTACH + 1))] = 2 x FanSpeed / KSCALE
246 * fCLK is the oscillator frequency (either the 254kHz internal
247 * oscillator or the externally applied clock)
249 * KTACH is the value in the speed register
251 * FanSpeed is the speed of the fan in rps
253 * KSCALE is the prescaler value (1, 2, 4, 8, or 16)
255 * When reading, we need to solve for FanSpeed. When writing, we need to
258 * Note: this tachometer is completely separate from the tachometers
259 * used to measure the fan speeds. Only one fan's speed (fan1) is
263 static ssize_t
fan1_target_show(struct device
*dev
,
264 struct device_attribute
*devattr
, char *buf
)
266 struct max6650_data
*data
= max6650_update_device(dev
);
267 int kscale
, ktach
, rpm
;
270 * Use the datasheet equation:
272 * FanSpeed = KSCALE x fCLK / [256 x (KTACH + 1)]
274 * then multiply by 60 to give rpm.
277 kscale
= DIV_FROM_REG(data
->config
);
279 rpm
= 60 * kscale
* clock
/ (256 * (ktach
+ 1));
280 return sprintf(buf
, "%d\n", rpm
);
283 static int max6650_set_target(struct max6650_data
*data
, unsigned long rpm
)
288 return max6650_set_operating_mode(data
, MAX6650_CFG_MODE_OFF
);
290 rpm
= clamp_val(rpm
, FAN_RPM_MIN
, FAN_RPM_MAX
);
293 * Divide the required speed by 60 to get from rpm to rps, then
294 * use the datasheet equation:
296 * KTACH = [(fCLK x KSCALE) / (256 x FanSpeed)] - 1
299 kscale
= DIV_FROM_REG(data
->config
);
300 ktach
= ((clock
* kscale
) / (256 * rpm
/ 60)) - 1;
307 return i2c_smbus_write_byte_data(data
->client
, MAX6650_REG_SPEED
,
311 static ssize_t
fan1_target_store(struct device
*dev
,
312 struct device_attribute
*devattr
,
313 const char *buf
, size_t count
)
315 struct max6650_data
*data
= dev_get_drvdata(dev
);
319 err
= kstrtoul(buf
, 10, &rpm
);
323 mutex_lock(&data
->update_lock
);
325 err
= max6650_set_target(data
, rpm
);
327 mutex_unlock(&data
->update_lock
);
336 * Get/set the fan speed in open loop mode using pwm1 sysfs file.
337 * Speed is given as a relative value from 0 to 255, where 255 is maximum
338 * speed. Note that this is done by writing directly to the chip's DAC,
339 * it won't change the closed loop speed set by fan1_target.
340 * Also note that due to rounding errors it is possible that you don't read
341 * back exactly the value you have set.
344 static ssize_t
pwm1_show(struct device
*dev
, struct device_attribute
*devattr
,
348 struct max6650_data
*data
= max6650_update_device(dev
);
351 * Useful range for dac is 0-180 for 12V fans and 0-76 for 5V fans.
352 * Lower DAC values mean higher speeds.
354 if (data
->config
& MAX6650_CFG_V12
)
355 pwm
= 255 - (255 * (int)data
->dac
)/180;
357 pwm
= 255 - (255 * (int)data
->dac
)/76;
362 return sprintf(buf
, "%d\n", pwm
);
365 static ssize_t
pwm1_store(struct device
*dev
,
366 struct device_attribute
*devattr
, const char *buf
,
369 struct max6650_data
*data
= dev_get_drvdata(dev
);
370 struct i2c_client
*client
= data
->client
;
374 err
= kstrtoul(buf
, 10, &pwm
);
378 pwm
= clamp_val(pwm
, 0, 255);
380 mutex_lock(&data
->update_lock
);
382 if (data
->config
& MAX6650_CFG_V12
)
383 data
->dac
= 180 - (180 * pwm
)/255;
385 data
->dac
= 76 - (76 * pwm
)/255;
386 err
= i2c_smbus_write_byte_data(client
, MAX6650_REG_DAC
, data
->dac
);
388 mutex_unlock(&data
->update_lock
);
390 return err
< 0 ? err
: count
;
394 * Get/Set controller mode:
397 * 1 = Open loop, Voltage is set according to speed, not regulated.
398 * 2 = Closed loop, RPM for all fans regulated by fan1 tachometer
401 static ssize_t
pwm1_enable_show(struct device
*dev
,
402 struct device_attribute
*devattr
, char *buf
)
404 struct max6650_data
*data
= max6650_update_device(dev
);
405 int mode
= (data
->config
& MAX6650_CFG_MODE_MASK
) >> 4;
406 int sysfs_modes
[4] = {0, 3, 2, 1};
408 return sprintf(buf
, "%d\n", sysfs_modes
[mode
]);
411 static ssize_t
pwm1_enable_store(struct device
*dev
,
412 struct device_attribute
*devattr
,
413 const char *buf
, size_t count
)
415 struct max6650_data
*data
= dev_get_drvdata(dev
);
418 const u8 max6650_modes
[] = {
420 MAX6650_CFG_MODE_OPEN_LOOP
,
421 MAX6650_CFG_MODE_CLOSED_LOOP
,
422 MAX6650_CFG_MODE_OFF
,
425 err
= kstrtoul(buf
, 10, &mode
);
429 if (mode
>= ARRAY_SIZE(max6650_modes
))
432 mutex_lock(&data
->update_lock
);
434 max6650_set_operating_mode(data
, max6650_modes
[mode
]);
436 mutex_unlock(&data
->update_lock
);
442 * Read/write functions for fan1_div sysfs file. The MAX6650 has no such
443 * divider. We handle this by converting between divider and counttime:
445 * (counttime == k) <==> (divider == 2^k), k = 0, 1, 2, or 3
447 * Lower values of k allow to connect a faster fan without the risk of
448 * counter overflow. The price is lower resolution. You can also set counttime
449 * using the module parameter. Note that the module parameter "prescaler" also
450 * influences the behaviour. Unfortunately, there's no sysfs attribute
451 * defined for that. See the data sheet for details.
454 static ssize_t
fan1_div_show(struct device
*dev
,
455 struct device_attribute
*devattr
, char *buf
)
457 struct max6650_data
*data
= max6650_update_device(dev
);
459 return sprintf(buf
, "%d\n", DIV_FROM_REG(data
->count
));
462 static ssize_t
fan1_div_store(struct device
*dev
,
463 struct device_attribute
*devattr
,
464 const char *buf
, size_t count
)
466 struct max6650_data
*data
= dev_get_drvdata(dev
);
467 struct i2c_client
*client
= data
->client
;
471 err
= kstrtoul(buf
, 10, &div
);
475 mutex_lock(&data
->update_lock
);
490 mutex_unlock(&data
->update_lock
);
494 i2c_smbus_write_byte_data(client
, MAX6650_REG_COUNT
, data
->count
);
495 mutex_unlock(&data
->update_lock
);
507 static ssize_t
alarm_show(struct device
*dev
,
508 struct device_attribute
*devattr
, char *buf
)
510 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
511 struct max6650_data
*data
= max6650_update_device(dev
);
512 struct i2c_client
*client
= data
->client
;
515 if (data
->alarm
& attr
->index
) {
516 mutex_lock(&data
->update_lock
);
518 data
->alarm
&= ~attr
->index
;
519 data
->alarm
|= i2c_smbus_read_byte_data(client
,
521 mutex_unlock(&data
->update_lock
);
524 return sprintf(buf
, "%d\n", alarm
);
527 static SENSOR_DEVICE_ATTR_RO(fan1_input
, fan
, 0);
528 static SENSOR_DEVICE_ATTR_RO(fan2_input
, fan
, 1);
529 static SENSOR_DEVICE_ATTR_RO(fan3_input
, fan
, 2);
530 static SENSOR_DEVICE_ATTR_RO(fan4_input
, fan
, 3);
531 static DEVICE_ATTR_RW(fan1_target
);
532 static DEVICE_ATTR_RW(fan1_div
);
533 static DEVICE_ATTR_RW(pwm1_enable
);
534 static DEVICE_ATTR_RW(pwm1
);
535 static SENSOR_DEVICE_ATTR_RO(fan1_max_alarm
, alarm
, MAX6650_ALRM_MAX
);
536 static SENSOR_DEVICE_ATTR_RO(fan1_min_alarm
, alarm
, MAX6650_ALRM_MIN
);
537 static SENSOR_DEVICE_ATTR_RO(fan1_fault
, alarm
, MAX6650_ALRM_TACH
);
538 static SENSOR_DEVICE_ATTR_RO(gpio1_alarm
, alarm
, MAX6650_ALRM_GPIO1
);
539 static SENSOR_DEVICE_ATTR_RO(gpio2_alarm
, alarm
, MAX6650_ALRM_GPIO2
);
541 static umode_t
max6650_attrs_visible(struct kobject
*kobj
, struct attribute
*a
,
544 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
545 struct max6650_data
*data
= dev_get_drvdata(dev
);
546 struct i2c_client
*client
= data
->client
;
547 u8 alarm_en
= i2c_smbus_read_byte_data(client
, MAX6650_REG_ALARM_EN
);
548 struct device_attribute
*devattr
;
551 * Hide the alarms that have not been enabled by the firmware
554 devattr
= container_of(a
, struct device_attribute
, attr
);
555 if (devattr
== &sensor_dev_attr_fan1_max_alarm
.dev_attr
556 || devattr
== &sensor_dev_attr_fan1_min_alarm
.dev_attr
557 || devattr
== &sensor_dev_attr_fan1_fault
.dev_attr
558 || devattr
== &sensor_dev_attr_gpio1_alarm
.dev_attr
559 || devattr
== &sensor_dev_attr_gpio2_alarm
.dev_attr
) {
560 if (!(alarm_en
& to_sensor_dev_attr(devattr
)->index
))
567 static struct attribute
*max6650_attrs
[] = {
568 &sensor_dev_attr_fan1_input
.dev_attr
.attr
,
569 &dev_attr_fan1_target
.attr
,
570 &dev_attr_fan1_div
.attr
,
571 &dev_attr_pwm1_enable
.attr
,
573 &sensor_dev_attr_fan1_max_alarm
.dev_attr
.attr
,
574 &sensor_dev_attr_fan1_min_alarm
.dev_attr
.attr
,
575 &sensor_dev_attr_fan1_fault
.dev_attr
.attr
,
576 &sensor_dev_attr_gpio1_alarm
.dev_attr
.attr
,
577 &sensor_dev_attr_gpio2_alarm
.dev_attr
.attr
,
581 static const struct attribute_group max6650_group
= {
582 .attrs
= max6650_attrs
,
583 .is_visible
= max6650_attrs_visible
,
586 static struct attribute
*max6651_attrs
[] = {
587 &sensor_dev_attr_fan2_input
.dev_attr
.attr
,
588 &sensor_dev_attr_fan3_input
.dev_attr
.attr
,
589 &sensor_dev_attr_fan4_input
.dev_attr
.attr
,
593 static const struct attribute_group max6651_group
= {
594 .attrs
= max6651_attrs
,
601 static int max6650_init_client(struct max6650_data
*data
,
602 struct i2c_client
*client
)
604 struct device
*dev
= &client
->dev
;
611 if (of_property_read_u32(dev
->of_node
, "maxim,fan-microvolt",
613 voltage
= fan_voltage
;
615 voltage
/= 1000000; /* Microvolts to volts */
616 if (of_property_read_u32(dev
->of_node
, "maxim,fan-prescale",
618 prescale
= prescaler
;
620 config
= i2c_smbus_read_byte_data(client
, MAX6650_REG_CONFIG
);
623 dev_err(dev
, "Error reading config, aborting.\n");
631 config
&= ~MAX6650_CFG_V12
;
634 config
|= MAX6650_CFG_V12
;
637 dev_err(dev
, "illegal value for fan_voltage (%d)\n", voltage
);
644 config
&= ~MAX6650_CFG_PRESCALER_MASK
;
647 config
= (config
& ~MAX6650_CFG_PRESCALER_MASK
)
648 | MAX6650_CFG_PRESCALER_2
;
651 config
= (config
& ~MAX6650_CFG_PRESCALER_MASK
)
652 | MAX6650_CFG_PRESCALER_4
;
655 config
= (config
& ~MAX6650_CFG_PRESCALER_MASK
)
656 | MAX6650_CFG_PRESCALER_8
;
659 config
= (config
& ~MAX6650_CFG_PRESCALER_MASK
)
660 | MAX6650_CFG_PRESCALER_16
;
663 dev_err(dev
, "illegal value for prescaler (%d)\n", prescale
);
666 dev_info(dev
, "Fan voltage: %dV, prescaler: %d.\n",
667 (config
& MAX6650_CFG_V12
) ? 12 : 5,
668 1 << (config
& MAX6650_CFG_PRESCALER_MASK
));
670 if (i2c_smbus_write_byte_data(client
, MAX6650_REG_CONFIG
, config
)) {
671 dev_err(dev
, "Config write error, aborting.\n");
675 data
->config
= config
;
676 data
->count
= i2c_smbus_read_byte_data(client
, MAX6650_REG_COUNT
);
678 if (!of_property_read_u32(client
->dev
.of_node
, "maxim,fan-target-rpm",
680 max6650_set_target(data
, target_rpm
);
681 max6650_set_operating_mode(data
, MAX6650_CFG_MODE_CLOSED_LOOP
);
687 #if IS_ENABLED(CONFIG_THERMAL)
689 static int max6650_get_max_state(struct thermal_cooling_device
*cdev
,
690 unsigned long *state
)
697 static int max6650_get_cur_state(struct thermal_cooling_device
*cdev
,
698 unsigned long *state
)
700 struct max6650_data
*data
= cdev
->devdata
;
702 *state
= data
->cooling_dev_state
;
707 static int max6650_set_cur_state(struct thermal_cooling_device
*cdev
,
710 struct max6650_data
*data
= cdev
->devdata
;
711 struct i2c_client
*client
= data
->client
;
714 state
= clamp_val(state
, 0, 255);
716 mutex_lock(&data
->update_lock
);
718 if (data
->config
& MAX6650_CFG_V12
)
719 data
->dac
= 180 - (180 * state
)/255;
721 data
->dac
= 76 - (76 * state
)/255;
723 err
= i2c_smbus_write_byte_data(client
, MAX6650_REG_DAC
, data
->dac
);
726 max6650_set_operating_mode(data
, state
?
727 MAX6650_CFG_MODE_OPEN_LOOP
:
728 MAX6650_CFG_MODE_OFF
);
729 data
->cooling_dev_state
= state
;
732 mutex_unlock(&data
->update_lock
);
734 return err
< 0 ? err
: 0;
737 static const struct thermal_cooling_device_ops max6650_cooling_ops
= {
738 .get_max_state
= max6650_get_max_state
,
739 .get_cur_state
= max6650_get_cur_state
,
740 .set_cur_state
= max6650_set_cur_state
,
744 static int max6650_probe(struct i2c_client
*client
,
745 const struct i2c_device_id
*id
)
747 struct device
*dev
= &client
->dev
;
748 const struct of_device_id
*of_id
=
749 of_match_device(of_match_ptr(max6650_dt_match
), dev
);
750 struct max6650_data
*data
;
751 struct device
*hwmon_dev
;
754 data
= devm_kzalloc(dev
, sizeof(struct max6650_data
), GFP_KERNEL
);
758 data
->client
= client
;
759 i2c_set_clientdata(client
, data
);
760 mutex_init(&data
->update_lock
);
761 data
->nr_fans
= of_id
? (int)(uintptr_t)of_id
->data
: id
->driver_data
;
764 * Initialize the max6650 chip
766 err
= max6650_init_client(data
, client
);
770 data
->groups
[0] = &max6650_group
;
771 /* 3 additional fan inputs for the MAX6651 */
772 if (data
->nr_fans
== 4)
773 data
->groups
[1] = &max6651_group
;
775 hwmon_dev
= devm_hwmon_device_register_with_groups(dev
,
778 err
= PTR_ERR_OR_ZERO(hwmon_dev
);
782 #if IS_ENABLED(CONFIG_THERMAL)
784 thermal_of_cooling_device_register(client
->dev
.of_node
,
786 &max6650_cooling_ops
);
787 if (IS_ERR(data
->cooling_dev
))
788 dev_warn(&client
->dev
,
789 "thermal cooling device register failed: %ld\n",
790 PTR_ERR(data
->cooling_dev
));
795 static int max6650_remove(struct i2c_client
*client
)
797 struct max6650_data
*data
= i2c_get_clientdata(client
);
799 if (!IS_ERR(data
->cooling_dev
))
800 thermal_cooling_device_unregister(data
->cooling_dev
);
805 static const struct i2c_device_id max6650_id
[] = {
810 MODULE_DEVICE_TABLE(i2c
, max6650_id
);
812 static struct i2c_driver max6650_driver
= {
815 .of_match_table
= of_match_ptr(max6650_dt_match
),
817 .probe
= max6650_probe
,
818 .remove
= max6650_remove
,
819 .id_table
= max6650_id
,
822 module_i2c_driver(max6650_driver
);
824 MODULE_AUTHOR("Hans J. Koch");
825 MODULE_DESCRIPTION("MAX6650 sensor driver");
826 MODULE_LICENSE("GPL");