hwmon: Add tc654 driver (aaf6fabf) · Commits · 方亚芬 / linux

Documentation/devicetree/bindings/i2c/trivial-devices.txt

+2 −0

Original line number	Diff line number	Diff line
		@@ -121,6 +121,8 @@ microchip,mcp4662-502 Microchip 8-bit Dual I2C Digital Potentiometer with NV Mem
		microchip,mcp4662-103 Microchip 8-bit Dual I2C Digital Potentiometer with NV Memory (10k)
		microchip,mcp4662-503 Microchip 8-bit Dual I2C Digital Potentiometer with NV Memory (50k)
		microchip,mcp4662-104 Microchip 8-bit Dual I2C Digital Potentiometer with NV Memory (100k)
		microchip,tc654 PWM Fan Speed Controller With Fan Fault Detection
		microchip,tc655 PWM Fan Speed Controller With Fan Fault Detection
		national,lm63 Temperature sensor with integrated fan control
		national,lm75 I2C TEMP SENSOR
		national,lm80 Serial Interface ACPI-Compatible Microprocessor System Hardware Monitor

Documentation/hwmon/tc654

0 → 100644

+31 −0

Original line number	Diff line number	Diff line
		Kernel driver tc654
		===================

		Supported chips:
		* Microship TC654 and TC655
		Prefix: 'tc654'
		Datasheet: http://ww1.microchip.com/downloads/en/DeviceDoc/20001734C.pdf

		Authors:
		Chris Packham <chris.packham@alliedtelesis.co.nz>
		Masahiko Iwamoto <iwamoto@allied-telesis.co.jp>

		Description
		-----------
		This driver implements support for the Microchip TC654 and TC655.

		The TC654 uses the 2-wire interface compatible with the SMBUS 2.0
		specification. The TC654 has two (2) inputs for measuring fan RPM and
		one (1) PWM output which can be used for fan control.

		Configuration Notes
		-------------------
		Ordinarily the pwm1_mode ABI is used for controlling the pwm output
		mode. However, for this chip the output is always pwm, and the
		pwm1_mode determines if the pwm output is controlled via the pwm1 value
		or via the Vin analog input.


		Setting pwm1_mode to 1 will cause the pwm output to be driven based on
		the pwm1 value. Setting pwm1_mode to 0 will cause the pwm output to be
		driven based on the Vin input.

drivers/hwmon/Kconfig

+11 −0

Original line number	Diff line number	Diff line
		@@ -907,6 +907,17 @@ config SENSORS_MCP3021
		This driver can also be built as a module. If so, the module
		will be called mcp3021.

		config SENSORS_TC654
		tristate "Microchip TC654/TC655 and compatibles"
		depends on I2C
		help
		If you say yes here you get support for TC654 and TC655.
		The TC654 and TC655 are PWM mode fan speed controllers with
		FanSense technology for use with brushless DC fans.

		This driver can also be built as a module. If so, the module
		will be called tc654.

		config SENSORS_MENF21BMC_HWMON
		tristate "MEN 14F021P00 BMC Hardware Monitoring"
		depends on MFD_MENF21BMC

drivers/hwmon/Makefile

+1 −0

Original line number	Diff line number	Diff line
		@@ -122,6 +122,7 @@ obj-$(CONFIG_SENSORS_MAX6697) += max6697.o
		obj-$(CONFIG_SENSORS_MAX31790) += max31790.o
		obj-$(CONFIG_SENSORS_MC13783_ADC)+= mc13783-adc.o
		obj-$(CONFIG_SENSORS_MCP3021) += mcp3021.o
		obj-$(CONFIG_SENSORS_TC654) += tc654.o
		obj-$(CONFIG_SENSORS_MENF21BMC_HWMON) += menf21bmc_hwmon.o
		obj-$(CONFIG_SENSORS_NCT6683) += nct6683.o
		obj-$(CONFIG_SENSORS_NCT6775) += nct6775.o

drivers/hwmon/tc654.c

0 → 100644

+514 −0

Original line number	Diff line number	Diff line
		/*
		* tc654.c - Linux kernel modules for fan speed controller
		*
		* Copyright (C) 2016 Allied Telesis Labs NZ
		*
		* This program is free software; you can redistribute it and/or modify
		* it under the terms of the GNU General Public License as published by
		* the Free Software Foundation; either version 2 of the License, or
		* (at your option) any later version.
		*
		* This program is distributed in the hope that it will be useful,
		* but WITHOUT ANY WARRANTY; without even the implied warranty of
		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		* GNU General Public License for more details.
		*/

		#include <linux/bitops.h>
		#include <linux/err.h>
		#include <linux/hwmon.h>
		#include <linux/hwmon-sysfs.h>
		#include <linux/i2c.h>
		#include <linux/init.h>
		#include <linux/jiffies.h>
		#include <linux/module.h>
		#include <linux/mutex.h>
		#include <linux/slab.h>
		#include <linux/util_macros.h>

		enum tc654_regs {
		TC654_REG_RPM1 = 0x00, /* RPM Output 1 */
		TC654_REG_RPM2 = 0x01, /* RPM Output 2 */
		TC654_REG_FAN_FAULT1 = 0x02, /* Fan Fault 1 Threshold */
		TC654_REG_FAN_FAULT2 = 0x03, /* Fan Fault 2 Threshold */
		TC654_REG_CONFIG = 0x04, /* Configuration */
		TC654_REG_STATUS = 0x05, /* Status */
		TC654_REG_DUTY_CYCLE = 0x06, /* Fan Speed Duty Cycle */
		TC654_REG_MFR_ID = 0x07, /* Manufacturer Identification */
		TC654_REG_VER_ID = 0x08, /* Version Identification */
		};

		/* Macros to easily index the registers */
		#define TC654_REG_RPM(idx) (TC654_REG_RPM1 + (idx))
		#define TC654_REG_FAN_FAULT(idx) (TC654_REG_FAN_FAULT1 + (idx))

		/* Config register bits */
		#define TC654_REG_CONFIG_RES BIT(6) /* Resolution Selection */
		#define TC654_REG_CONFIG_DUTYC BIT(5) /* Duty Cycle Control */
		#define TC654_REG_CONFIG_SDM BIT(0) /* Shutdown Mode */

		/* Status register bits */
		#define TC654_REG_STATUS_F2F BIT(1) /* Fan 2 Fault */
		#define TC654_REG_STATUS_F1F BIT(0) /* Fan 1 Fault */

		/* RPM resolution for RPM Output registers */
		#define TC654_HIGH_RPM_RESOLUTION 25 /* 25 RPM resolution */
		#define TC654_LOW_RPM_RESOLUTION 50 /* 50 RPM resolution */

		/* Convert to the fan fault RPM threshold from register value */
		#define TC654_FAN_FAULT_FROM_REG(val) ((val) * 50) /* 50 RPM resolution */

		/* Convert to register value from the fan fault RPM threshold */
		#define TC654_FAN_FAULT_TO_REG(val) (((val) / 50) & 0xff)

		/* Register data is read (and cached) at most once per second. */
		#define TC654_UPDATE_INTERVAL HZ

		struct tc654_data {
		struct i2c_client *client;

		/* update mutex */
		struct mutex update_lock;

		/* tc654 register cache */
		bool valid;
		unsigned long last_updated; /* in jiffies */

		u8 rpm_output[2]; /* The fan RPM data for fans 1 and 2 is then
		* written to registers RPM1 and RPM2
		*/
		u8 fan_fault[2]; /* The Fan Fault Threshold Registers are used to
		* set the fan fault threshold levels for fan 1
		* and fan 2
		*/
		u8 config; /* The Configuration Register is an 8-bit read/
		* writable multi-function control register
		* 7: Fan Fault Clear
		* 1 = Clear Fan Fault
		* 0 = Normal Operation (default)
		* 6: Resolution Selection for RPM Output Registers
		* RPM Output Registers (RPM1 and RPM2) will be
		* set for
		* 1 = 25 RPM (9-bit) resolution
		* 0 = 50 RPM (8-bit) resolution (default)
		* 5: Duty Cycle Control Method
		* The V OUT duty cycle will be controlled via
		* 1 = the SMBus interface.
		* 0 = via the V IN analog input pin. (default)
		* 4,3: Fan 2 Pulses Per Rotation
		* 00 = 1
		* 01 = 2 (default)
		* 10 = 4
		* 11 = 8
		* 2,1: Fan 1 Pulses Per Rotation
		* 00 = 1
		* 01 = 2 (default)
		* 10 = 4
		* 11 = 8
		* 0: Shutdown Mode
		* 1 = Shutdown mode.
		* 0 = Normal operation. (default)
		*/
		u8 status; /* The Status register provides all the information
		* about what is going on within the TC654/TC655
		* devices.
		* 7,6: Unimplemented, Read as '0'
		* 5: Over-Temperature Fault Condition
		* 1 = Over-Temperature condition has occurred
		* 0 = Normal operation. V IN is less than 2.6V
		* 4: RPM2 Counter Overflow
		* 1 = Fault condition
		* 0 = Normal operation
		* 3: RPM1 Counter Overflow
		* 1 = Fault condition
		* 0 = Normal operation
		* 2: V IN Input Status
		* 1 = V IN is open
		* 0 = Normal operation. voltage present at V IN
		* 1: Fan 2 Fault
		* 1 = Fault condition
		* 0 = Normal operation
		* 0: Fan 1 Fault
		* 1 = Fault condition
		* 0 = Normal operation
		*/
		u8 duty_cycle; /* The DUTY_CYCLE register is a 4-bit read/
		* writable register used to control the duty
		* cycle of the V OUT output.
		*/
		};

		/* helper to grab and cache data, at most one time per second */
		static struct tc654_data tc654_update_client(struct device dev)
		{
		struct tc654_data *data = dev_get_drvdata(dev);
		struct i2c_client *client = data->client;
		int ret = 0;

		mutex_lock(&data->update_lock);
		if (time_before(jiffies, data->last_updated + TC654_UPDATE_INTERVAL) &&
		likely(data->valid))
		goto out;

		ret = i2c_smbus_read_byte_data(client, TC654_REG_RPM(0));
		if (ret < 0)
		goto out;
		data->rpm_output[0] = ret;

		ret = i2c_smbus_read_byte_data(client, TC654_REG_RPM(1));
		if (ret < 0)
		goto out;
		data->rpm_output[1] = ret;

		ret = i2c_smbus_read_byte_data(client, TC654_REG_FAN_FAULT(0));
		if (ret < 0)
		goto out;
		data->fan_fault[0] = ret;

		ret = i2c_smbus_read_byte_data(client, TC654_REG_FAN_FAULT(1));
		if (ret < 0)
		goto out;
		data->fan_fault[1] = ret;

		ret = i2c_smbus_read_byte_data(client, TC654_REG_CONFIG);
		if (ret < 0)
		goto out;
		data->config = ret;

		ret = i2c_smbus_read_byte_data(client, TC654_REG_STATUS);
		if (ret < 0)
		goto out;
		data->status = ret;

		ret = i2c_smbus_read_byte_data(client, TC654_REG_DUTY_CYCLE);
		if (ret < 0)
		goto out;
		data->duty_cycle = ret & 0x0f;

		data->last_updated = jiffies;
		data->valid = true;
		out:
		mutex_unlock(&data->update_lock);

		if (ret < 0) /* upon error, encode it in return value */
		data = ERR_PTR(ret);

		return data;
		}

		/*
		* sysfs attributes
		*/

		static ssize_t show_fan(struct device dev, struct device_attribute da,
		char *buf)
		{
		int nr = to_sensor_dev_attr(da)->index;
		struct tc654_data *data = tc654_update_client(dev);
		int val;

		if (IS_ERR(data))
		return PTR_ERR(data);

		if (data->config & TC654_REG_CONFIG_RES)
		val = data->rpm_output[nr] * TC654_HIGH_RPM_RESOLUTION;
		else
		val = data->rpm_output[nr] * TC654_LOW_RPM_RESOLUTION;

		return sprintf(buf, "%d\n", val);
		}

		static ssize_t show_fan_min(struct device dev, struct device_attribute da,
		char *buf)
		{
		int nr = to_sensor_dev_attr(da)->index;
		struct tc654_data *data = tc654_update_client(dev);

		if (IS_ERR(data))
		return PTR_ERR(data);

		return sprintf(buf, "%d\n",
		TC654_FAN_FAULT_FROM_REG(data->fan_fault[nr]));
		}

		static ssize_t set_fan_min(struct device dev, struct device_attribute da,
		const char *buf, size_t count)
		{
		int nr = to_sensor_dev_attr(da)->index;
		struct tc654_data *data = dev_get_drvdata(dev);
		struct i2c_client *client = data->client;
		unsigned long val;
		int ret;

		if (kstrtoul(buf, 10, &val))
		return -EINVAL;

		val = clamp_val(val, 0, 12750);

		mutex_lock(&data->update_lock);

		data->fan_fault[nr] = TC654_FAN_FAULT_TO_REG(val);
		ret = i2c_smbus_write_byte_data(client, TC654_REG_FAN_FAULT(nr),
		data->fan_fault[nr]);

		mutex_unlock(&data->update_lock);
		return ret < 0 ? ret : count;
		}

		static ssize_t show_fan_alarm(struct device dev, struct device_attribute da,
		char *buf)
		{
		int nr = to_sensor_dev_attr(da)->index;
		struct tc654_data *data = tc654_update_client(dev);
		int val;

		if (IS_ERR(data))
		return PTR_ERR(data);

		if (nr == 0)
		val = !!(data->status & TC654_REG_STATUS_F1F);
		else
		val = !!(data->status & TC654_REG_STATUS_F2F);

		return sprintf(buf, "%d\n", val);
		}

		static const u8 TC654_FAN_PULSE_SHIFT[] = { 1, 3 };

		static ssize_t show_fan_pulses(struct device dev, struct device_attribute da,
		char *buf)
		{
		int nr = to_sensor_dev_attr(da)->index;
		struct tc654_data *data = tc654_update_client(dev);
		u8 val;

		if (IS_ERR(data))
		return PTR_ERR(data);

		val = BIT((data->config >> TC654_FAN_PULSE_SHIFT[nr]) & 0x03);
		return sprintf(buf, "%d\n", val);
		}

		static ssize_t set_fan_pulses(struct device dev, struct device_attribute da,
		const char *buf, size_t count)
		{
		int nr = to_sensor_dev_attr(da)->index;
		struct tc654_data *data = dev_get_drvdata(dev);
		struct i2c_client *client = data->client;
		u8 config;
		unsigned long val;
		int ret;

		if (kstrtoul(buf, 10, &val))
		return -EINVAL;

		switch (val) {
		case 1:
		config = 0;
		break;
		case 2:
		config = 1;
		break;
		case 4:
		config = 2;
		break;
		case 8:
		config = 3;
		break;
		default:
		return -EINVAL;
		}

		mutex_lock(&data->update_lock);

		data->config &= ~(0x03 << TC654_FAN_PULSE_SHIFT[nr]);
		data->config \|= (config << TC654_FAN_PULSE_SHIFT[nr]);
		ret = i2c_smbus_write_byte_data(client, TC654_REG_CONFIG, data->config);

		mutex_unlock(&data->update_lock);
		return ret < 0 ? ret : count;
		}

		static ssize_t show_pwm_mode(struct device *dev,
		struct device_attribute da, char buf)
		{
		struct tc654_data *data = tc654_update_client(dev);

		if (IS_ERR(data))
		return PTR_ERR(data);

		return sprintf(buf, "%d\n", !!(data->config & TC654_REG_CONFIG_DUTYC));
		}

		static ssize_t set_pwm_mode(struct device *dev,
		struct device_attribute *da,
		const char *buf, size_t count)
		{
		struct tc654_data *data = dev_get_drvdata(dev);
		struct i2c_client *client = data->client;
		unsigned long val;
		int ret;

		if (kstrtoul(buf, 10, &val))
		return -EINVAL;

		if (val != 0 && val != 1)
		return -EINVAL;

		mutex_lock(&data->update_lock);

		if (val)
		data->config \|= TC654_REG_CONFIG_DUTYC;
		else
		data->config &= ~TC654_REG_CONFIG_DUTYC;

		ret = i2c_smbus_write_byte_data(client, TC654_REG_CONFIG, data->config);

		mutex_unlock(&data->update_lock);
		return ret < 0 ? ret : count;
		}

		static const int tc654_pwm_map[16] = { 77, 88, 102, 112, 124, 136, 148, 160,
		172, 184, 196, 207, 219, 231, 243, 255};

		static ssize_t show_pwm(struct device dev, struct device_attribute da,
		char *buf)
		{
		struct tc654_data *data = tc654_update_client(dev);
		int pwm;

		if (IS_ERR(data))
		return PTR_ERR(data);

		if (data->config & TC654_REG_CONFIG_SDM)
		pwm = 0;
		else
		pwm = tc654_pwm_map[data->duty_cycle];

		return sprintf(buf, "%d\n", pwm);
		}

		static ssize_t set_pwm(struct device dev, struct device_attribute da,
		const char *buf, size_t count)
		{
		struct tc654_data *data = dev_get_drvdata(dev);
		struct i2c_client *client = data->client;
		unsigned long val;
		int ret;

		if (kstrtoul(buf, 10, &val))
		return -EINVAL;
		if (val > 255)
		return -EINVAL;

		mutex_lock(&data->update_lock);

		if (val == 0)
		data->config \|= TC654_REG_CONFIG_SDM;
		else
		data->config &= ~TC654_REG_CONFIG_SDM;

		data->duty_cycle = find_closest(val, tc654_pwm_map,
		ARRAY_SIZE(tc654_pwm_map));

		ret = i2c_smbus_write_byte_data(client, TC654_REG_CONFIG, data->config);
		if (ret < 0)
		goto out;

		ret = i2c_smbus_write_byte_data(client, TC654_REG_DUTY_CYCLE,
		data->duty_cycle);

		out:
		mutex_unlock(&data->update_lock);
		return ret < 0 ? ret : count;
		}

		static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0);
		static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1);
		static SENSOR_DEVICE_ATTR(fan1_min, S_IWUSR \| S_IRUGO, show_fan_min,
		set_fan_min, 0);
		static SENSOR_DEVICE_ATTR(fan2_min, S_IWUSR \| S_IRUGO, show_fan_min,
		set_fan_min, 1);
		static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_fan_alarm, NULL, 0);
		static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_fan_alarm, NULL, 1);
		static SENSOR_DEVICE_ATTR(fan1_pulses, S_IWUSR \| S_IRUGO, show_fan_pulses,
		set_fan_pulses, 0);
		static SENSOR_DEVICE_ATTR(fan2_pulses, S_IWUSR \| S_IRUGO, show_fan_pulses,
		set_fan_pulses, 1);
		static SENSOR_DEVICE_ATTR(pwm1_mode, S_IWUSR \| S_IRUGO,
		show_pwm_mode, set_pwm_mode, 0);
		static SENSOR_DEVICE_ATTR(pwm1, S_IWUSR \| S_IRUGO, show_pwm,
		set_pwm, 0);

		/* Driver data */
		static struct attribute *tc654_attrs[] = {
		&sensor_dev_attr_fan1_input.dev_attr.attr,
		&sensor_dev_attr_fan2_input.dev_attr.attr,
		&sensor_dev_attr_fan1_min.dev_attr.attr,
		&sensor_dev_attr_fan2_min.dev_attr.attr,
		&sensor_dev_attr_fan1_alarm.dev_attr.attr,
		&sensor_dev_attr_fan2_alarm.dev_attr.attr,
		&sensor_dev_attr_fan1_pulses.dev_attr.attr,
		&sensor_dev_attr_fan2_pulses.dev_attr.attr,
		&sensor_dev_attr_pwm1_mode.dev_attr.attr,
		&sensor_dev_attr_pwm1.dev_attr.attr,
		NULL
		};

		ATTRIBUTE_GROUPS(tc654);

		/*
		* device probe and removal
		*/

		static int tc654_probe(struct i2c_client *client,
		const struct i2c_device_id *id)
		{
		struct device *dev = &client->dev;
		struct tc654_data *data;
		struct device *hwmon_dev;
		int ret;

		if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
		return -ENODEV;

		data = devm_kzalloc(dev, sizeof(struct tc654_data), GFP_KERNEL);
		if (!data)
		return -ENOMEM;

		data->client = client;
		mutex_init(&data->update_lock);

		ret = i2c_smbus_read_byte_data(client, TC654_REG_CONFIG);
		if (ret < 0)
		return ret;

		data->config = ret;

		hwmon_dev =
		devm_hwmon_device_register_with_groups(dev, client->name, data,
		tc654_groups);
		return PTR_ERR_OR_ZERO(hwmon_dev);
		}

		static const struct i2c_device_id tc654_id[] = {
		{"tc654", 0},
		{"tc655", 0},
		{}
		};

		MODULE_DEVICE_TABLE(i2c, tc654_id);

		static struct i2c_driver tc654_driver = {
		.driver = {
		.name = "tc654",
		},
		.probe = tc654_probe,
		.id_table = tc654_id,
		};

		module_i2c_driver(tc654_driver);

		MODULE_AUTHOR("Allied Telesis Labs");
		MODULE_DESCRIPTION("Microchip TC654/TC655 driver");
		MODULE_LICENSE("GPL");