Orange Pi5 kernel

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Driver for MAX31730 3-Channel Remote Temperature Sensor
 *
 * Copyright (c) 2019 Guenter Roeck <linux@roeck-us.net>
 */
 
#include <linux/bits.h>
#include <linux/err.h>
#include <linux/i2c.h>
#include <linux/init.h>
#include <linux/hwmon.h>
#include <linux/module.h>
#include <linux/of_device.h>
#include <linux/of.h>
#include <linux/slab.h>
 
/* Addresses scanned */
static const unsigned short normal_i2c[] = { 0x1c, 0x1d, 0x1e, 0x1f, 0x4c,
<------><------><------><------><------>     0x4d, 0x4e, 0x4f, I2C_CLIENT_END };
 
/* The MAX31730 registers */
#define MAX31730_REG_TEMP		0x00
#define MAX31730_REG_CONF		0x13
#define  MAX31730_STOP			BIT(7)
#define  MAX31730_EXTRANGE		BIT(1)
#define MAX31730_REG_TEMP_OFFSET	0x16
#define  MAX31730_TEMP_OFFSET_BASELINE	0x77
#define MAX31730_REG_OFFSET_ENABLE	0x17
#define MAX31730_REG_TEMP_MAX		0x20
#define MAX31730_REG_TEMP_MIN		0x30
#define MAX31730_REG_STATUS_HIGH	0x32
#define MAX31730_REG_STATUS_LOW		0x33
#define MAX31730_REG_CHANNEL_ENABLE	0x35
#define MAX31730_REG_TEMP_FAULT		0x36
 
#define MAX31730_REG_MFG_ID		0x50
#define  MAX31730_MFG_ID		0x4d
#define MAX31730_REG_MFG_REV		0x51
#define  MAX31730_MFG_REV		0x01
 
#define MAX31730_TEMP_MIN		(-128000)
#define MAX31730_TEMP_MAX		127937
 
/* Each client has this additional data */
struct max31730_data {
<------>struct i2c_client	*client;
<------>u8			orig_conf;
<------>u8			current_conf;
<------>u8			offset_enable;
<------>u8			channel_enable;
};
 
/*-----------------------------------------------------------------------*/
 
static inline long max31730_reg_to_mc(s16 temp)
{
<------>return DIV_ROUND_CLOSEST((temp >> 4) * 1000, 16);
}
 
static int max31730_write_config(struct max31730_data *data, u8 set_mask,
<------><------><------><------> u8 clr_mask)
{
<------>u8 value;
 
<------>clr_mask |= MAX31730_EXTRANGE;
<------>value = data->current_conf & ~clr_mask;
<------>value |= set_mask;
 
<------>if (data->current_conf != value) {
<------><------>s32 err;
 
<------><------>err = i2c_smbus_write_byte_data(data->client, MAX31730_REG_CONF,
<------><------><------><------><------><------>value);
<------><------>if (err)
<------><------><------>return err;
<------><------>data->current_conf = value;
<------>}
<------>return 0;
}
 
static int max31730_set_enable(struct i2c_client *client, int reg,
<------><------><------>       u8 *confdata, int channel, bool enable)
{
<------>u8 regval = *confdata;
<------>int err;
 
<------>if (enable)
<------><------>regval |= BIT(channel);
<------>else
<------><------>regval &= ~BIT(channel);
 
<------>if (regval != *confdata) {
<------><------>err = i2c_smbus_write_byte_data(client, reg, regval);
<------><------>if (err)
<------><------><------>return err;
<------><------>*confdata = regval;
<------>}
<------>return 0;
}
 
static int max31730_set_offset_enable(struct max31730_data *data, int channel,
<------><------><------><------>      bool enable)
{
<------>return max31730_set_enable(data->client, MAX31730_REG_OFFSET_ENABLE,
<------><------><------><------>   &data->offset_enable, channel, enable);
}
 
static int max31730_set_channel_enable(struct max31730_data *data, int channel,
<------><------><------><------>       bool enable)
{
<------>return max31730_set_enable(data->client, MAX31730_REG_CHANNEL_ENABLE,
<------><------><------><------>   &data->channel_enable, channel, enable);
}
 
static int max31730_read(struct device *dev, enum hwmon_sensor_types type,
<------><------><------> u32 attr, int channel, long *val)
{
<------>struct max31730_data *data = dev_get_drvdata(dev);
<------>int regval, reg, offset;
 
<------>if (type != hwmon_temp)
<------><------>return -EINVAL;
 
<------>switch (attr) {
<------>case hwmon_temp_input:
<------><------>if (!(data->channel_enable & BIT(channel)))
<------><------><------>return -ENODATA;
<------><------>reg = MAX31730_REG_TEMP + (channel * 2);
<------><------>break;
<------>case hwmon_temp_max:
<------><------>reg = MAX31730_REG_TEMP_MAX + (channel * 2);
<------><------>break;
<------>case hwmon_temp_min:
<------><------>reg = MAX31730_REG_TEMP_MIN;
<------><------>break;
<------>case hwmon_temp_enable:
<------><------>*val = !!(data->channel_enable & BIT(channel));
<------><------>return 0;
<------>case hwmon_temp_offset:
<------><------>if (!channel)
<------><------><------>return -EINVAL;
<------><------>if (!(data->offset_enable & BIT(channel))) {
<------><------><------>*val = 0;
<------><------><------>return 0;
<------><------>}
<------><------>offset = i2c_smbus_read_byte_data(data->client,
<------><------><------><------><------><------>  MAX31730_REG_TEMP_OFFSET);
<------><------>if (offset < 0)
<------><------><------>return offset;
<------><------>*val = (offset - MAX31730_TEMP_OFFSET_BASELINE) * 125;
<------><------>return 0;
<------>case hwmon_temp_fault:
<------><------>regval = i2c_smbus_read_byte_data(data->client,
<------><------><------><------><------><------>  MAX31730_REG_TEMP_FAULT);
<------><------>if (regval < 0)
<------><------><------>return regval;
<------><------>*val = !!(regval & BIT(channel));
<------><------>return 0;
<------>case hwmon_temp_min_alarm:
<------><------>regval = i2c_smbus_read_byte_data(data->client,
<------><------><------><------><------><------>  MAX31730_REG_STATUS_LOW);
<------><------>if (regval < 0)
<------><------><------>return regval;
<------><------>*val = !!(regval & BIT(channel));
<------><------>return 0;
<------>case hwmon_temp_max_alarm:
<------><------>regval = i2c_smbus_read_byte_data(data->client,
<------><------><------><------><------><------>  MAX31730_REG_STATUS_HIGH);
<------><------>if (regval < 0)
<------><------><------>return regval;
<------><------>*val = !!(regval & BIT(channel));
<------><------>return 0;
<------>default:
<------><------>return -EINVAL;
<------>}
<------>regval = i2c_smbus_read_word_swapped(data->client, reg);
<------>if (regval < 0)
<------><------>return regval;
 
<------>*val = max31730_reg_to_mc(regval);
 
<------>return 0;
}
 
static int max31730_write(struct device *dev, enum hwmon_sensor_types type,
<------><------><------>  u32 attr, int channel, long val)
{
<------>struct max31730_data *data = dev_get_drvdata(dev);
<------>int reg, err;
 
<------>if (type != hwmon_temp)
<------><------>return -EINVAL;
 
<------>switch (attr) {
<------>case hwmon_temp_max:
<------><------>reg = MAX31730_REG_TEMP_MAX + channel * 2;
<------><------>break;
<------>case hwmon_temp_min:
<------><------>reg = MAX31730_REG_TEMP_MIN;
<------><------>break;
<------>case hwmon_temp_enable:
<------><------>if (val != 0 && val != 1)
<------><------><------>return -EINVAL;
<------><------>return max31730_set_channel_enable(data, channel, val);
<------>case hwmon_temp_offset:
<------><------>val = clamp_val(val, -14875, 17000) + 14875;
<------><------>val = DIV_ROUND_CLOSEST(val, 125);
<------><------>err = max31730_set_offset_enable(data, channel,
<------><------><------><------><------>val != MAX31730_TEMP_OFFSET_BASELINE);
<------><------>if (err)
<------><------><------>return err;
<------><------>return i2c_smbus_write_byte_data(data->client,
<------><------><------><------><------><------> MAX31730_REG_TEMP_OFFSET, val);
<------>default:
<------><------>return -EINVAL;
<------>}
 
<------>val = clamp_val(val, MAX31730_TEMP_MIN, MAX31730_TEMP_MAX);
<------>val = DIV_ROUND_CLOSEST(val << 4, 1000) << 4;
 
<------>return i2c_smbus_write_word_swapped(data->client, reg, (u16)val);
}
 
static umode_t max31730_is_visible(const void *data,
<------><------><------><------>   enum hwmon_sensor_types type,
<------><------><------><------>   u32 attr, int channel)
{
<------>switch (type) {
<------>case hwmon_temp:
<------><------>switch (attr) {
<------><------>case hwmon_temp_input:
<------><------>case hwmon_temp_min_alarm:
<------><------>case hwmon_temp_max_alarm:
<------><------>case hwmon_temp_fault:
<------><------><------>return 0444;
<------><------>case hwmon_temp_min:
<------><------><------>return channel ? 0444 : 0644;
<------><------>case hwmon_temp_offset:
<------><------>case hwmon_temp_enable:
<------><------>case hwmon_temp_max:
<------><------><------>return 0644;
<------><------>}
<------><------>break;
<------>default:
<------><------>break;
<------>}
<------>return 0;
}
 
static const struct hwmon_channel_info *max31730_info[] = {
<------>HWMON_CHANNEL_INFO(chip,
<------><------><------>   HWMON_C_REGISTER_TZ),
<------>HWMON_CHANNEL_INFO(temp,
<------><------><------>   HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX |
<------><------><------>   HWMON_T_ENABLE |
<------><------><------>   HWMON_T_MIN_ALARM | HWMON_T_MAX_ALARM,
<------><------><------>   HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX |
<------><------><------>   HWMON_T_OFFSET | HWMON_T_ENABLE |
<------><------><------>   HWMON_T_MIN_ALARM | HWMON_T_MAX_ALARM |
<------><------><------>   HWMON_T_FAULT,
<------><------><------>   HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX |
<------><------><------>   HWMON_T_OFFSET | HWMON_T_ENABLE |
<------><------><------>   HWMON_T_MIN_ALARM | HWMON_T_MAX_ALARM |
<------><------><------>   HWMON_T_FAULT,
<------><------><------>   HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX |
<------><------><------>   HWMON_T_OFFSET | HWMON_T_ENABLE |
<------><------><------>   HWMON_T_MIN_ALARM | HWMON_T_MAX_ALARM |
<------><------><------>   HWMON_T_FAULT
<------><------><------>   ),
<------>NULL
};
 
static const struct hwmon_ops max31730_hwmon_ops = {
<------>.is_visible = max31730_is_visible,
<------>.read = max31730_read,
<------>.write = max31730_write,
};
 
static const struct hwmon_chip_info max31730_chip_info = {
<------>.ops = &max31730_hwmon_ops,
<------>.info = max31730_info,
};
 
static void max31730_remove(void *data)
{
<------>struct max31730_data *max31730 = data;
<------>struct i2c_client *client = max31730->client;
 
<------>i2c_smbus_write_byte_data(client, MAX31730_REG_CONF,
<------><------><------><------>  max31730->orig_conf);
}
 
static int
max31730_probe(struct i2c_client *client)
{
<------>struct device *dev = &client->dev;
<------>struct device *hwmon_dev;
<------>struct max31730_data *data;
<------>int status, err;
 
<------>if (!i2c_check_functionality(client->adapter,
<------><------><------>I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA))
<------><------>return -EIO;
 
<------>data = devm_kzalloc(dev, sizeof(struct max31730_data), GFP_KERNEL);
<------>if (!data)
<------><------>return -ENOMEM;
 
<------>data->client = client;
 
<------>/* Cache original configuration and enable status */
<------>status = i2c_smbus_read_byte_data(client, MAX31730_REG_CHANNEL_ENABLE);
<------>if (status < 0)
<------><------>return status;
<------>data->channel_enable = status;
 
<------>status = i2c_smbus_read_byte_data(client, MAX31730_REG_OFFSET_ENABLE);
<------>if (status < 0)
<------><------>return status;
<------>data->offset_enable = status;
 
<------>status = i2c_smbus_read_byte_data(client, MAX31730_REG_CONF);
<------>if (status < 0)
<------><------>return status;
<------>data->orig_conf = status;
<------>data->current_conf = status;
 
<------>err = max31730_write_config(data,
<------><------><------><------>    data->channel_enable ? 0 : MAX31730_STOP,
<------><------><------><------>    data->channel_enable ? MAX31730_STOP : 0);
<------>if (err)
<------><------>return err;
 
<------>dev_set_drvdata(dev, data);
 
<------>err = devm_add_action_or_reset(dev, max31730_remove, data);
<------>if (err)
<------><------>return err;
 
<------>hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name,
<------><------><------><------><------><------><------> data,
<------><------><------><------><------><------><------> &max31730_chip_info,
<------><------><------><------><------><------><------> NULL);
<------>return PTR_ERR_OR_ZERO(hwmon_dev);
}
 
static const struct i2c_device_id max31730_ids[] = {
<------>{ "max31730", 0, },
<------>{ }
};
MODULE_DEVICE_TABLE(i2c, max31730_ids);
 
static const struct of_device_id __maybe_unused max31730_of_match[] = {
<------>{
<------><------>.compatible = "maxim,max31730",
<------>},
<------>{ },
};
MODULE_DEVICE_TABLE(of, max31730_of_match);
 
static bool max31730_check_reg_temp(struct i2c_client *client,
<------><------><------><------>    int reg)
{
<------>int regval;
 
<------>regval = i2c_smbus_read_byte_data(client, reg + 1);
<------>return regval < 0 || (regval & 0x0f);
}
 
/* Return 0 if detection is successful, -ENODEV otherwise */
static int max31730_detect(struct i2c_client *client,
<------><------><------>   struct i2c_board_info *info)
{
<------>struct i2c_adapter *adapter = client->adapter;
<------>int regval;
<------>int i;
 
<------>if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
<------><------><------><------>     I2C_FUNC_SMBUS_WORD_DATA))
<------><------>return -ENODEV;
 
<------>regval = i2c_smbus_read_byte_data(client, MAX31730_REG_MFG_ID);
<------>if (regval != MAX31730_MFG_ID)
<------><------>return -ENODEV;
<------>regval = i2c_smbus_read_byte_data(client, MAX31730_REG_MFG_REV);
<------>if (regval != MAX31730_MFG_REV)
<------><------>return -ENODEV;
 
<------>/* lower 4 bit of temperature and limit registers must be 0 */
<------>if (max31730_check_reg_temp(client, MAX31730_REG_TEMP_MIN))
<------><------>return -ENODEV;
 
<------>for (i = 0; i < 4; i++) {
<------><------>if (max31730_check_reg_temp(client, MAX31730_REG_TEMP + i * 2))
<------><------><------>return -ENODEV;
<------><------>if (max31730_check_reg_temp(client,
<------><------><------><------><------>    MAX31730_REG_TEMP_MAX + i * 2))
<------><------><------>return -ENODEV;
<------>}
 
<------>strlcpy(info->type, "max31730", I2C_NAME_SIZE);
 
<------>return 0;
}
 
static int __maybe_unused max31730_suspend(struct device *dev)
{
<------>struct max31730_data *data = dev_get_drvdata(dev);
 
<------>return max31730_write_config(data, MAX31730_STOP, 0);
}
 
static int __maybe_unused max31730_resume(struct device *dev)
{
<------>struct max31730_data *data = dev_get_drvdata(dev);
 
<------>return max31730_write_config(data, 0, MAX31730_STOP);
}
 
static SIMPLE_DEV_PM_OPS(max31730_pm_ops, max31730_suspend, max31730_resume);
 
static struct i2c_driver max31730_driver = {
<------>.class		= I2C_CLASS_HWMON,
<------>.driver = {
<------><------>.name	= "max31730",
<------><------>.of_match_table = of_match_ptr(max31730_of_match),
<------><------>.pm	= &max31730_pm_ops,
<------>},
<------>.probe_new	= max31730_probe,
<------>.id_table	= max31730_ids,
<------>.detect		= max31730_detect,
<------>.address_list	= normal_i2c,
};
 
module_i2c_driver(max31730_driver);
 
MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>");
MODULE_DESCRIPTION("MAX31730 driver");
MODULE_LICENSE("GPL");