ina260-sysfs-driver/ina260.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Driver for Texas Instruments INA260 power monitor chip
 * Datasheet: https://www.ti.com/lit/gpn/INA260
 *
 * Copyright (C) 2023 GUEGAN Loic <loic.guegan@mailbox.org>
 */

#include "linux/module.h"
#include "linux/uaccess.h"
#include "linux/i2c.h"
#include "linux/kobject.h"
#include "linux/slab.h"
#include "linux/kernel.h"
#include <linux/sysfs.h>
#include <linux/hwmon.h>
#include <linux/regmap.h>

// INA260 registers
#define INA260_REG_CONFIGURATION  0x00
#define INA260_REG_CURRENT        0x01
#define INA260_REG_VOLTAGE        0x02
#define INA260_REG_POWER          0x03
#define INA260_REG_MASKENABLE     0x06
#define INA260_REG_ALERTLIMIT     0x07
#define INA260_REG_MANUFACTURER   0xFE
#define INA260_REG_DIE            0xFF

static struct regmap_config ina260_regmap_config = {
	.max_register = INA260_REG_DIE,
	.reg_bits = 8,
	.val_bits = 16,
};

#define INA260_REG_SHOW(_attr, _reg) \
static ssize_t _attr##_show(struct device *dev, struct device_attribute *attr, char *buf) \
{ \
	unsigned int rvalue; \
	int err; \
	struct client_data *cdata = dev_get_drvdata(dev); \
	err = regmap_read(cdata->regmap, (_reg), &rvalue); \
	if (err > 0) \
		return err; \
	return sprintf(buf, "0x%x\n", rvalue); \
}

#define INA260_REG_STORE(_attr, _reg) \
static ssize_t _attr##_store(struct device *dev, struct device_attribute *attr, \
const char *buf, size_t count) \
{ \
	int uvalue, err; \
	struct client_data *cdata = dev_get_drvdata(dev); \
	if (kstrtoint(buf, 0, &uvalue)) \
		return -EINVAL; \
	err = regmap_write(cdata->regmap, (_reg), uvalue); \
	if (err > 0) \
		return err; \
	return count; \
}

/**
 * @brief Embedded user data
 */
struct client_data {
	struct i2c_client *client;
	struct regmap *regmap;
};

static int ina260_hwmon_read(struct device *dev, enum hwmon_sensor_types type,
							u32 attr, int channel, long *val)
{
	int rvalue, reg, err;
	struct client_data *cdata = dev_get_drvdata(dev);

	switch (type) {
	case hwmon_power:
		reg = INA260_REG_POWER;
		break;
	case hwmon_curr:
		reg = INA260_REG_CURRENT;
		break;
	case hwmon_in:
		reg = INA260_REG_VOLTAGE;
		break;
	default:
		return -EOPNOTSUPP;
	}
	err = regmap_read(cdata->regmap, reg, &rvalue);
	if (err < 0)
		return err;
	else if (type == hwmon_power)
		*val = rvalue * 10000;
	else
		*val = div_u64(rvalue * 25, 100) + rvalue;
	return 0;
}

static int ina260_hwmon_write(struct device *dev, enum hwmon_sensor_types type,
		       u32 attr, int channel, long val)
{
	return -EOPNOTSUPP;
}

INA260_REG_SHOW(configuration, INA260_REG_CONFIGURATION)
INA260_REG_SHOW(curr, INA260_REG_CURRENT)
INA260_REG_SHOW(bus_voltage, INA260_REG_VOLTAGE)
INA260_REG_SHOW(power, INA260_REG_POWER)
INA260_REG_SHOW(mask_enable, INA260_REG_MASKENABLE)
INA260_REG_SHOW(alert_limit, INA260_REG_ALERTLIMIT)
INA260_REG_SHOW(manufacturer_id, INA260_REG_MANUFACTURER)
INA260_REG_SHOW(die_id, INA260_REG_DIE)

INA260_REG_STORE(configuration, INA260_REG_CONFIGURATION)
INA260_REG_STORE(curr, INA260_REG_CURRENT)
INA260_REG_STORE(bus_voltage, INA260_REG_VOLTAGE)
INA260_REG_STORE(power, INA260_REG_POWER)
INA260_REG_STORE(mask_enable, INA260_REG_MASKENABLE)
INA260_REG_STORE(alert_limit, INA260_REG_ALERTLIMIT)

static umode_t ina260_hwmon_is_visible(const void *drvdata,
								enum hwmon_sensor_types type, u32 attr, int channel)
{
	return 0444;
}

static const struct hwmon_channel_info *ina260_hwmon_info[] = {
	HWMON_CHANNEL_INFO(in, HWMON_I_INPUT),
	HWMON_CHANNEL_INFO(power, HWMON_P_INPUT),
	HWMON_CHANNEL_INFO(curr, HWMON_C_INPUT),
	NULL
};

static const struct hwmon_ops ina260_hwmon_ops = {
	.is_visible = ina260_hwmon_is_visible,
	.read = ina260_hwmon_read,
	.write = ina260_hwmon_write,
};

static const struct hwmon_chip_info ina260_chip_info = {
	.ops = &ina260_hwmon_ops,
	.info = ina260_hwmon_info,
};

// ----- Registers -----
static DEVICE_ATTR_RW(configuration);
static DEVICE_ATTR_RW(curr);
static DEVICE_ATTR_RW(bus_voltage);
static DEVICE_ATTR_RW(power);
static DEVICE_ATTR_RW(mask_enable);
static DEVICE_ATTR_RW(alert_limit);
static DEVICE_ATTR_RO(manufacturer_id);
static DEVICE_ATTR_RO(die_id);
static struct attribute *registers_attrs[] = {
	&dev_attr_configuration.attr,
	&dev_attr_curr.attr,
	&dev_attr_bus_voltage.attr,
	&dev_attr_power.attr,
	&dev_attr_mask_enable.attr,
	&dev_attr_alert_limit.attr,
	&dev_attr_manufacturer_id.attr,
	&dev_attr_die_id.attr,
	NULL,
};
static const struct attribute_group registers_group = {
	.attrs = registers_attrs,
	.name = "registers"
};

const struct attribute_group *extra_groups[] = {
	&registers_group,
	NULL
};

static int ina260_probe_new(struct i2c_client *client)
{
	struct client_data *p;
	struct device *hwmon_dev;

	// Initialize client data:
	printk(KERN_INFO "Adding ina260 [bus=%d address=0x%02x]\n",
	       client->adapter->nr, client->addr);
	p = kzalloc(sizeof(struct client_data), GFP_KERNEL);
	p->client = client;
	p->regmap = devm_regmap_init_i2c(client, &ina260_regmap_config);

	hwmon_dev = hwmon_device_register_with_info(&client->dev, client->name, p,
	&ina260_chip_info, extra_groups);
	if (IS_ERR(hwmon_dev))
		return PTR_ERR(hwmon_dev);
	return 0;
}

static void ina260_remove(struct i2c_client *client)
{
	struct client_data *p = i2c_get_clientdata(client);

	kfree(p);
	hwmon_device_unregister(&client->dev);
	printk(KERN_INFO "Removing ina260 [bus=%d address=0x%02x]\n", client->adapter->nr, client->addr);
}

static const struct i2c_device_id ina260_ids[] = {
	{ "ina260", 0 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, ina260_ids);

static struct i2c_driver ina260_driver = {
	.class = I2C_CLASS_HWMON,
	.driver = {
		.name = "ina260"
	},
	.probe_new = ina260_probe_new,
	.remove = ina260_remove,
	.id_table = ina260_ids
};

static int __init ina260_init(void)
{
	i2c_add_driver(&ina260_driver);
	return 0;
}

static void __exit ina260_exit(void)
{
	i2c_del_driver(&ina260_driver);
}

module_init(ina260_init);
module_exit(ina260_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Loïc Guegan");
MODULE_DESCRIPTION("INA260 Texas Instruments");
MODULE_VERSION("1.0");