Re: [PATCH v1 6/9] hwmon: Add Nuvoton NCT6694 HWMON support

[Guenter Roeck <linux@roeck-us.net>]

On 10/24/24 01:59, Ming Yu wrote:
> This driver supports Hardware monitor functionality for NCT6694 MFD
> device based on USB interface.
> 
> Signed-off-by: Ming Yu <tmyu0@nuvoton.com>
> ---
>   MAINTAINERS                   |   1 +
>   drivers/hwmon/Kconfig         |  10 +
>   drivers/hwmon/Makefile        |   1 +
>   drivers/hwmon/nct6694-hwmon.c | 407 ++++++++++++++++++++++++++++++++++
>   4 files changed, 419 insertions(+)
>   create mode 100644 drivers/hwmon/nct6694-hwmon.c
> 
> diff --git a/MAINTAINERS b/MAINTAINERS
> index 63387c0d4ab6..2aa87ad84156 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -16439,6 +16439,7 @@ M:	Ming Yu <tmyu0@nuvoton.com>
>   L:	linux-kernel@vger.kernel.org
>   S:	Supported
>   F:	drivers/gpio/gpio-nct6694.c
> +F:	drivers/hwmon/nct6694-hwmon.c
>   F:	drivers/i2c/busses/i2c-nct6694.c
>   F:	drivers/mfd/nct6694.c
>   F:	drivers/net/can/nct6694_canfd.c
> diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
> index 08a3c863f80a..740e4afe6582 100644
> --- a/drivers/hwmon/Kconfig
> +++ b/drivers/hwmon/Kconfig
> @@ -1625,6 +1625,16 @@ config SENSORS_NCT6683
>   	  This driver can also be built as a module. If so, the module
>   	  will be called nct6683.
>   
> +config SENSORS_NCT6694
> +	tristate "Nuvoton NCT6694 Hardware Monitor support"
> +	depends on MFD_NCT6694
> +	help
> +	  Say Y here to support Nuvoton NCT6694 hardware monitoring
> +	  functionality.
> +
> +	  This driver can also be built as a module. If so, the module
> +	  will be called nct6694-hwmon.
> +
>   config SENSORS_NCT6775_CORE
>   	tristate
>   	select REGMAP
> diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
> index 9554d2fdcf7b..729961176d00 100644
> --- a/drivers/hwmon/Makefile
> +++ b/drivers/hwmon/Makefile
> @@ -167,6 +167,7 @@ obj-$(CONFIG_SENSORS_MLXREG_FAN) += mlxreg-fan.o
>   obj-$(CONFIG_SENSORS_MENF21BMC_HWMON) += menf21bmc_hwmon.o
>   obj-$(CONFIG_SENSORS_MR75203)	+= mr75203.o
>   obj-$(CONFIG_SENSORS_NCT6683)	+= nct6683.o
> +obj-$(CONFIG_SENSORS_NCT6694)	+= nct6694-hwmon.o
>   obj-$(CONFIG_SENSORS_NCT6775_CORE) += nct6775-core.o
>   nct6775-objs			:= nct6775-platform.o
>   obj-$(CONFIG_SENSORS_NCT6775)	+= nct6775.o
> diff --git a/drivers/hwmon/nct6694-hwmon.c b/drivers/hwmon/nct6694-hwmon.c
> new file mode 100644
> index 000000000000..7d7d22a650b0
> --- /dev/null
> +++ b/drivers/hwmon/nct6694-hwmon.c
> @@ -0,0 +1,407 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Nuvoton NCT6694 HWMON driver based on USB interface.
> + *
> + * Copyright (C) 2024 Nuvoton Technology Corp.
> + */
> +
> +#include <linux/slab.h>
> +#include <linux/kernel.h>
> +#include <linux/module.h>
> +#include <linux/hwmon.h>
> +#include <linux/platform_device.h>
> +#include <linux/mfd/nct6694.h>
> +
> +#define DRVNAME "nct6694-hwmon"
> +
> +/* Host interface */
> +#define REQUEST_RPT_MOD			0xFF
> +#define REQUEST_HWMON_MOD		0x00
> +
> +/* Report Channel */
> +#define HWMON_FIN_IDX(x)		(0x50 + ((x) * 2))
> +#define HWMON_FIN_STS(x)		(0x6E + (x))
> +#define HWMON_PWM_IDX(x)		(0x70 + (x))
> +
> +/* Message Channel*/
> +/* Command 00h */
> +#define REQUEST_HWMON_CMD0_LEN		0x40
> +#define REQUEST_HWMON_CMD0_OFFSET	0x0000	/* OFFSET = SEL|CMD */
> +#define HWMON_FIN_EN(x)			(0x04 + (x))
> +#define HWMON_PWM_FREQ_IDX(x)		(0x30 + (x))
> +/* Command 02h */
> +#define REQUEST_HWMON_CMD2_LEN		0x90
> +#define REQUEST_HWMON_CMD2_OFFSET	0x0002	/* OFFSET = SEL|CMD */
> +#define HWMON_SMI_CTRL_IDX		0x00
> +#define HWMON_FIN_LIMIT_IDX(x)		(0x70 + ((x) * 2))
> +#define HWMON_CMD2_HYST_MASK		0x1F
> +/* Command 03h */
> +#define REQUEST_HWMON_CMD3_LEN		0x08
> +#define REQUEST_HWMON_CMD3_OFFSET	0x0003	/* OFFSET = SEL|CMD */
> +
> +struct nct6694_hwmon_data {
> +	struct nct6694 *nct6694;
> +
> +	/* Make sure read & write commands are consecutive */
> +	struct mutex hwmon_lock;
> +};
> +
> +#define NCT6694_HWMON_FAN_CONFIG (HWMON_F_ENABLE | HWMON_F_INPUT | \
> +				  HWMON_F_MIN | HWMON_F_MIN_ALARM)
> +#define NCT6694_HWMON_PWM_CONFIG (HWMON_PWM_INPUT | HWMON_PWM_FREQ)
> +
> +static const struct hwmon_channel_info *nct6694_info[] = {
> +	HWMON_CHANNEL_INFO(fan,
> +			   NCT6694_HWMON_FAN_CONFIG,	/* FIN0 */
> +			   NCT6694_HWMON_FAN_CONFIG,	/* FIN1 */
> +			   NCT6694_HWMON_FAN_CONFIG,	/* FIN2 */
> +			   NCT6694_HWMON_FAN_CONFIG,	/* FIN3 */
> +			   NCT6694_HWMON_FAN_CONFIG,	/* FIN4 */
> +			   NCT6694_HWMON_FAN_CONFIG,	/* FIN5 */
> +			   NCT6694_HWMON_FAN_CONFIG,	/* FIN6 */
> +			   NCT6694_HWMON_FAN_CONFIG,	/* FIN7 */
> +			   NCT6694_HWMON_FAN_CONFIG,	/* FIN8 */
> +			   NCT6694_HWMON_FAN_CONFIG),	/* FIN9 */
> +
> +	HWMON_CHANNEL_INFO(pwm,
> +			   NCT6694_HWMON_PWM_CONFIG,	/* PWM0 */
> +			   NCT6694_HWMON_PWM_CONFIG,	/* PWM1 */
> +			   NCT6694_HWMON_PWM_CONFIG,	/* PWM2 */
> +			   NCT6694_HWMON_PWM_CONFIG,	/* PWM3 */
> +			   NCT6694_HWMON_PWM_CONFIG,	/* PWM4 */
> +			   NCT6694_HWMON_PWM_CONFIG,	/* PWM5 */
> +			   NCT6694_HWMON_PWM_CONFIG,	/* PWM6 */
> +			   NCT6694_HWMON_PWM_CONFIG,	/* PWM7 */
> +			   NCT6694_HWMON_PWM_CONFIG,	/* PWM8 */
> +			   NCT6694_HWMON_PWM_CONFIG),	/* PWM9 */
> +	NULL
> +};
> +
> +static int nct6694_fan_read(struct device *dev, u32 attr, int channel,
> +			    long *val)
> +{
> +	struct nct6694_hwmon_data *data = dev_get_drvdata(dev);
> +	unsigned char buf[2];
> +	int ret;
> +
> +	switch (attr) {
> +	case hwmon_fan_enable:
> +		ret = nct6694_read_msg(data->nct6694, REQUEST_HWMON_MOD,
> +				       REQUEST_HWMON_CMD0_OFFSET,
> +				       REQUEST_HWMON_CMD0_LEN,
> +				       HWMON_FIN_EN(channel / 8),
> +				       1, buf);
> +		if (ret)
> +			return -EINVAL;

Do not overwrite error return values.

> +
> +		*val = buf[0] & BIT(channel % 8) ? 1 : 0;
> +
> +		break;
> +
> +	case hwmon_fan_input:
> +		ret = nct6694_read_msg(data->nct6694, REQUEST_RPT_MOD,
> +				       HWMON_FIN_IDX(channel), 2, 0,
> +				       2, buf);
> +		if (ret)
> +			return -EINVAL;
> +
> +		*val = (buf[1] | (buf[0] << 8)) & 0xFFFF;
> +
> +		break;
> +
> +	case hwmon_fan_min:
> +		ret = nct6694_read_msg(data->nct6694, REQUEST_HWMON_MOD,
> +				       REQUEST_HWMON_CMD2_OFFSET,
> +				       REQUEST_HWMON_CMD2_LEN,
> +				       HWMON_FIN_LIMIT_IDX(channel),
> +				       2, buf);
> +		if (ret)
> +			return -EINVAL;
> +
> +		*val = (buf[1] | (buf[0] << 8)) & 0xFFFF;
> +
> +		break;
> +
> +	case hwmon_fan_min_alarm:
> +		ret = nct6694_read_msg(data->nct6694, REQUEST_RPT_MOD,
> +				       HWMON_FIN_STS(channel / 8),
> +				       1, 0, 1, buf);
> +		if (ret)
> +			return -EINVAL;
> +
> +		*val = buf[0] & BIT(channel % 8);
> +
> +		break;
> +
> +	default:
> +		return -EOPNOTSUPP;
> +	}
> +
> +	return 0;
> +}
> +
> +static int nct6694_pwm_read(struct device *dev, u32 attr, int channel,
> +			    long *val)
> +{
> +	struct nct6694_hwmon_data *data = dev_get_drvdata(dev);
> +	unsigned char buf;
> +	int ret;
> +
> +	switch (attr) {
> +	case hwmon_pwm_input:
> +		ret = nct6694_read_msg(data->nct6694, REQUEST_RPT_MOD,
> +				       HWMON_PWM_IDX(channel),
> +				       1, 0, 1, &buf);
> +		if (ret)
> +			return -EINVAL;
> +
> +		*val = buf;
> +
> +		break;
> +	case hwmon_pwm_freq:
> +		ret = nct6694_read_msg(data->nct6694, REQUEST_HWMON_MOD,
> +				       REQUEST_HWMON_CMD0_OFFSET,
> +				       REQUEST_HWMON_CMD0_LEN,
> +				       HWMON_PWM_FREQ_IDX(channel),
> +				       1, &buf);
> +		if (ret)
> +			return -EINVAL;
> +
> +		*val = buf * 25000 / 255;
> +
> +		break;
> +
> +	default:
> +		return -EOPNOTSUPP;
> +	}
> +
> +	return 0;
> +}
> +
> +static int nct6694_fan_write(struct device *dev, u32 attr, int channel,
> +			     long val)
> +{
> +	struct nct6694_hwmon_data *data = dev_get_drvdata(dev);
> +	unsigned char enable_buf[REQUEST_HWMON_CMD0_LEN] = {0};
> +	unsigned char buf[REQUEST_HWMON_CMD2_LEN] = {0};
> +	u16 fan_val = (u16)val;

This is wrong. It will result in overflows/underflows if out of range
values are provided, and the driver should not write 0 if the user
writes 65536. You need to use clamp_val() instead. For values with
well defined range (specifically hwmon_fan_enable) you need to validate
the parameter, not just take it as boolean.

> +	int ret;
> +
> +	switch (attr) {
> +	case hwmon_fan_enable:
> +		mutex_lock(&data->hwmon_lock);
> +		ret = nct6694_read_msg(data->nct6694, REQUEST_HWMON_MOD,
> +				       REQUEST_HWMON_CMD0_OFFSET,
> +				       REQUEST_HWMON_CMD0_LEN, 0,
> +				       REQUEST_HWMON_CMD0_LEN,
> +				       enable_buf);
> +		if (ret)
> +			goto err;
> +
> +		if (val)
> +			enable_buf[HWMON_FIN_EN(channel / 8)] |= BIT(channel % 8);
> +		else
> +			enable_buf[HWMON_FIN_EN(channel / 8)] &= ~BIT(channel % 8);
> +
> +		ret = nct6694_write_msg(data->nct6694, REQUEST_HWMON_MOD,
> +					REQUEST_HWMON_CMD0_OFFSET,
> +					REQUEST_HWMON_CMD0_LEN, enable_buf);
> +		if (ret)
> +			goto err;
> +
> +		break;
> +
> +	case hwmon_fan_min:
> +		mutex_lock(&data->hwmon_lock);
> +		ret = nct6694_read_msg(data->nct6694, REQUEST_HWMON_MOD,
> +				       REQUEST_HWMON_CMD2_OFFSET,
> +				       REQUEST_HWMON_CMD2_LEN, 0,
> +				       REQUEST_HWMON_CMD2_LEN, buf);
> +		if (ret)
> +			goto err;
> +
> +		buf[HWMON_FIN_LIMIT_IDX(channel)] = (u8)((fan_val >> 8) & 0xFF);
> +		buf[HWMON_FIN_LIMIT_IDX(channel) + 1] = (u8)(fan_val & 0xFF);
> +		ret = nct6694_write_msg(data->nct6694, REQUEST_HWMON_MOD,
> +					REQUEST_HWMON_CMD2_OFFSET,
> +					REQUEST_HWMON_CMD2_LEN, buf);
> +		if (ret)
> +			goto err;
> +
> +		break;

The error handler goto and the break accomplish exactly the same,
thus the conditional goto is pointless.

> +
> +	default:
> +		ret = -EOPNOTSUPP;
> +		goto err;

As mentioned in my other reply, the lock is not acquired here,
causing an unbalanced unlock.

> +	}
> +
> +err:
> +	mutex_unlock(&data->hwmon_lock);
> +	return ret;
> +}
> +
> +static int nct6694_read(struct device *dev, enum hwmon_sensor_types type,
> +			u32 attr, int channel, long *val)
> +{
> +	switch (type) {
> +	case hwmon_fan:	/* in RPM */
> +		return nct6694_fan_read(dev, attr, channel, val);
> +
> +	case hwmon_pwm:	/* in value 0~255 */
> +		return nct6694_pwm_read(dev, attr, channel, val);
> +
> +	default:
> +		return -EOPNOTSUPP;
> +	}
> +
> +	return 0;

Unnecessary return statement. Also seen elsewhere.

> +}
> +
> +static int nct6694_write(struct device *dev, enum hwmon_sensor_types type,
> +			 u32 attr, int channel, long val)
> +{
> +	switch (type) {
> +	case hwmon_fan:
> +		return nct6694_fan_write(dev, attr, channel, val);
> +	default:
> +		return -EOPNOTSUPP;
> +	}
> +
> +	return 0;
> +}
> +
> +static umode_t nct6694_is_visible(const void *data, enum hwmon_sensor_types type,
> +				  u32 attr, int channel)
> +{
> +	switch (type) {
> +	case hwmon_fan:
> +		switch (attr) {
> +		case hwmon_fan_enable:
> +		case hwmon_fan_min:
> +			return 0644;
> +
> +		case hwmon_fan_input:
> +		case hwmon_fan_min_alarm:
> +			return 0444;
> +
> +		default:
> +			return 0;
> +		}
> +
> +	case hwmon_pwm:
> +		switch (attr) {
> +		case hwmon_pwm_input:
> +		case hwmon_pwm_freq:
> +			return 0444;
> +		default:
> +			return 0;
> +		}
> +
> +	default:
> +		return 0;
> +	}
> +
> +	return 0;
> +}
> +
> +static const struct hwmon_ops nct6694_hwmon_ops = {
> +	.is_visible = nct6694_is_visible,
> +	.read = nct6694_read,
> +	.write = nct6694_write,
> +};
> +
> +static const struct hwmon_chip_info nct6694_chip_info = {
> +	.ops = &nct6694_hwmon_ops,
> +	.info = nct6694_info,
> +};
> +
> +static int nct6694_hwmon_init(struct nct6694_hwmon_data *data)
> +{
> +	unsigned char buf[REQUEST_HWMON_CMD2_LEN] = {0};
> +	int ret;
> +
> +	/* Set Fan input Real Time alarm mode */
> +	mutex_lock(&data->hwmon_lock);

Pointless lock (this is init code)

> +	ret = nct6694_read_msg(data->nct6694, REQUEST_HWMON_MOD,
> +			       REQUEST_HWMON_CMD2_OFFSET,
> +			       REQUEST_HWMON_CMD2_LEN, 0,
> +			       REQUEST_HWMON_CMD2_LEN, buf);
> +	if (ret)
> +		goto err;
> +
> +	buf[HWMON_SMI_CTRL_IDX] = 0x02;
> +
> +	ret = nct6694_write_msg(data->nct6694, REQUEST_HWMON_MOD,
> +				REQUEST_HWMON_CMD2_OFFSET,
> +				REQUEST_HWMON_CMD2_LEN, buf);
> +	if (ret)
> +		goto err;
> +
> +err:
> +	mutex_unlock(&data->hwmon_lock);
> +	return ret;
> +}
> +
> +static int nct6694_hwmon_probe(struct platform_device *pdev)
> +{
> +	struct nct6694_hwmon_data *data;
> +	struct nct6694 *nct6694 = dev_get_drvdata(pdev->dev.parent);
> +	struct device *hwmon_dev;
> +	int ret;
> +
> +	data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
> +	if (!data)
> +		return -ENOMEM;
> +
> +	data->nct6694 = nct6694;
> +	mutex_init(&data->hwmon_lock);
> +	platform_set_drvdata(pdev, data);
> +
> +	ret = nct6694_hwmon_init(data);
> +	if (ret)
> +		return -EIO;

Again, do not overwrite error codes.

> +
> +	/* Register hwmon device to HWMON framework */
> +	hwmon_dev = devm_hwmon_device_register_with_info(&pdev->dev,
> +							 "nct6694", data,
> +							 &nct6694_chip_info,
> +							 NULL);
> +	if (IS_ERR(hwmon_dev)) {
> +		dev_err(&pdev->dev, "%s: Failed to register hwmon device!\n",
> +			__func__);

Use dev_err_probe(), and the function name is pointless.

> +		return PTR_ERR(hwmon_dev);
> +	}
> +
> +	return 0;
> +}
> +
> +static struct platform_driver nct6694_hwmon_driver = {
> +	.driver = {
> +		.name	= DRVNAME,
> +	},
> +	.probe		= nct6694_hwmon_probe,
> +};
> +
> +static int __init nct6694_init(void)
> +{
> +	int err;
> +
> +	err = platform_driver_register(&nct6694_hwmon_driver);
> +	if (!err) {
> +		if (err)

Seriously ? Read this code again. It is never reached (and pointless).

> +			platform_driver_unregister(&nct6694_hwmon_driver);
> +	}
> +
> +	return err;
> +}
> +subsys_initcall(nct6694_init);
> +
> +static void __exit nct6694_exit(void)
> +{
> +	platform_driver_unregister(&nct6694_hwmon_driver);
> +}
> +module_exit(nct6694_exit);
> +
> +MODULE_DESCRIPTION("USB-HWMON driver for NCT6694");
> +MODULE_AUTHOR("Ming Yu <tmyu0@nuvoton.com>");
> +MODULE_LICENSE("GPL");