ARK-OS/arkos/kernel/drivers/misc/eeprom/m24lr.c

// SPDX-License-Identifier: GPL-2.0
/*
 * m24lr.c - Sysfs control interface for ST M24LR series RFID/NFC chips
 *
 * Copyright (c) 2025 Abd-Alrhman Masalkhi <abd.masalkhi@gmail.com>
 *
 * This driver implements both the sysfs-based control interface and EEPROM
 * access for STMicroelectronics M24LR series chips (e.g., M24LR04E-R).
 * It provides access to control registers for features such as password
 * authentication, memory protection, and device configuration. In addition,
 * it manages read and write operations to the EEPROM region of the chip.
 */

#include <linux/device.h>
#include <linux/i2c.h>
#include <linux/module.h>
#include <linux/nvmem-provider.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/regmap.h>

#define M24LR_WRITE_TIMEOUT	  25u
#define M24LR_READ_TIMEOUT	  (M24LR_WRITE_TIMEOUT)

/**
 * struct m24lr_chip - describes chip-specific sysfs layout
 * @sss_len:       the length of the sss region
 * @page_size:	   chip-specific limit on the maximum number of bytes allowed
 *		   in a single write operation.
 * @eeprom_size:   size of the EEPROM in byte
 *
 * Supports multiple M24LR chip variants (e.g., M24LRxx) by allowing each
 * to define its own set of sysfs attributes, depending on its available
 * registers and features.
 */
struct m24lr_chip {
	unsigned int sss_len;
	unsigned int page_size;
	unsigned int eeprom_size;
};

/**
 * struct m24lr - core driver data for M24LR chip control
 * @uid:           64 bits unique identifier stored in the device
 * @sss_len:       the length of the sss region
 * @page_size:	   chip-specific limit on the maximum number of bytes allowed
 *		   in a single write operation.
 * @eeprom_size:   size of the EEPROM in byte
 * @ctl_regmap:	   regmap interface for accessing the system parameter sector
 * @eeprom_regmap: regmap interface for accessing the EEPROM
 * @lock:	   mutex to synchronize operations to the device
 *
 * Central data structure holding the state and resources used by the
 * M24LR device driver.
 */
struct m24lr {
	u64 uid;
	unsigned int sss_len;
	unsigned int page_size;
	unsigned int eeprom_size;
	struct regmap *ctl_regmap;
	struct regmap *eeprom_regmap;
	struct mutex lock;	 /* synchronize operations to the device */
};

static const struct regmap_range m24lr_ctl_vo_ranges[] = {
	regmap_reg_range(0, 63),
};

static const struct regmap_access_table m24lr_ctl_vo_table = {
	.yes_ranges = m24lr_ctl_vo_ranges,
	.n_yes_ranges = ARRAY_SIZE(m24lr_ctl_vo_ranges),
};

static const struct regmap_config m24lr_ctl_regmap_conf = {
	.name = "m24lr_ctl",
	.reg_stride = 1,
	.reg_bits = 16,
	.val_bits = 8,
	.disable_locking = false,
	.cache_type = REGCACHE_RBTREE,/* Flat can't be used, there's huge gap */
	.volatile_table = &m24lr_ctl_vo_table,
};

/* Chip descriptor for M24LR04E-R variant */
static const struct m24lr_chip m24lr04e_r_chip = {
	.page_size = 4,
	.eeprom_size = 512,
	.sss_len = 4,
};

/* Chip descriptor for M24LR16E-R variant */
static const struct m24lr_chip m24lr16e_r_chip = {
	.page_size = 4,
	.eeprom_size = 2048,
	.sss_len = 16,
};

/* Chip descriptor for M24LR64E-R variant */
static const struct m24lr_chip m24lr64e_r_chip = {
	.page_size = 4,
	.eeprom_size = 8192,
	.sss_len = 64,
};

static const struct i2c_device_id m24lr_ids[] = {
	{ "m24lr04e-r", (kernel_ulong_t)&m24lr04e_r_chip},
	{ "m24lr16e-r", (kernel_ulong_t)&m24lr16e_r_chip},
	{ "m24lr64e-r", (kernel_ulong_t)&m24lr64e_r_chip},
	{ }
};
MODULE_DEVICE_TABLE(i2c, m24lr_ids);

static const struct of_device_id m24lr_of_match[] = {
	{ .compatible = "st,m24lr04e-r", .data = &m24lr04e_r_chip},
	{ .compatible = "st,m24lr16e-r", .data = &m24lr16e_r_chip},
	{ .compatible = "st,m24lr64e-r", .data = &m24lr64e_r_chip},
	{ }
};
MODULE_DEVICE_TABLE(of, m24lr_of_match);

/**
 * m24lr_regmap_read - read data using regmap with retry on failure
 * @regmap:  regmap instance for the device
 * @buf:     buffer to store the read data
 * @size:    number of bytes to read
 * @offset:  starting register address
 *
 * Attempts to read a block of data from the device with retries and timeout.
 * Some M24LR chips may transiently NACK reads (e.g., during internal write
 * cycles), so this function retries with a short sleep until the timeout
 * expires.
 *
 * Returns:
 *	 Number of bytes read on success,
 *	 -ETIMEDOUT if the read fails within the timeout window.
 */
static ssize_t m24lr_regmap_read(struct regmap *regmap, u8 *buf,
				 size_t size, unsigned int offset)
{
	int err;
	unsigned long timeout, read_time;
	ssize_t ret = -ETIMEDOUT;

	timeout = jiffies + msecs_to_jiffies(M24LR_READ_TIMEOUT);
	do {
		read_time = jiffies;

		err = regmap_bulk_read(regmap, offset, buf, size);
		if (!err) {
			ret = size;
			break;
		}

		usleep_range(1000, 2000);
	} while (time_before(read_time, timeout));

	return ret;
}

/**
 * m24lr_regmap_write - write data using regmap with retry on failure
 * @regmap: regmap instance for the device
 * @buf:    buffer containing the data to write
 * @size:   number of bytes to write
 * @offset: starting register address
 *
 * Attempts to write a block of data to the device with retries and a timeout.
 * Some M24LR devices may NACK I2C writes while an internal write operation
 * is in progress. This function retries the write operation with a short delay
 * until it succeeds or the timeout is reached.
 *
 * Returns:
 *	 Number of bytes written on success,
 *	 -ETIMEDOUT if the write fails within the timeout window.
 */
static ssize_t m24lr_regmap_write(struct regmap *regmap, const u8 *buf,
				  size_t size, unsigned int offset)
{
	int err;
	unsigned long timeout, write_time;
	ssize_t ret = -ETIMEDOUT;

	timeout = jiffies + msecs_to_jiffies(M24LR_WRITE_TIMEOUT);

	do {
		write_time = jiffies;

		err = regmap_bulk_write(regmap, offset, buf, size);
		if (!err) {
			ret = size;
			break;
		}

		usleep_range(1000, 2000);
	} while (time_before(write_time, timeout));

	return ret;
}

static ssize_t m24lr_read(struct m24lr *m24lr, u8 *buf, size_t size,
			  unsigned int offset, bool is_eeprom)
{
	struct regmap *regmap;
	ssize_t ret;

	if (is_eeprom)
		regmap = m24lr->eeprom_regmap;
	else
		regmap = m24lr->ctl_regmap;

	mutex_lock(&m24lr->lock);
	ret = m24lr_regmap_read(regmap, buf, size, offset);
	mutex_unlock(&m24lr->lock);

	return ret;
}

/**
 * m24lr_write - write buffer to M24LR device with page alignment handling
 * @m24lr:     pointer to driver context
 * @buf:       data buffer to write
 * @size:      number of bytes to write
 * @offset:    target register address in the device
 * @is_eeprom: true if the write should target the EEPROM,
 *             false if it should target the system parameters sector.
 *
 * Writes data to the M24LR device using regmap, split into chunks no larger
 * than page_size to respect device-specific write limitations (e.g., page
 * size or I2C hold-time concerns). Each chunk is aligned to the page boundary
 * defined by page_size.
 *
 * Returns:
 *	 Total number of bytes written on success,
 *	 A negative error code if any write fails.
 */
static ssize_t m24lr_write(struct m24lr *m24lr, const u8 *buf, size_t size,
			   unsigned int offset, bool is_eeprom)
{
	unsigned int n, next_sector;
	struct regmap *regmap;
	ssize_t ret = 0;
	ssize_t err;

	if (is_eeprom)
		regmap = m24lr->eeprom_regmap;
	else
		regmap = m24lr->ctl_regmap;

	n = min_t(unsigned int, size, m24lr->page_size);
	next_sector = roundup(offset + 1, m24lr->page_size);
	if (offset + n > next_sector)
		n = next_sector - offset;

	mutex_lock(&m24lr->lock);
	while (n) {
		err = m24lr_regmap_write(regmap, buf + offset, n, offset);
		if (IS_ERR_VALUE(err)) {
			if (!ret)
				ret = err;

			break;
		}

		offset += n;
		size -= n;
		ret += n;
		n = min_t(unsigned int, size, m24lr->page_size);
	}
	mutex_unlock(&m24lr->lock);

	return ret;
}

/**
 * m24lr_write_pass - Write password to M24LR043-R using secure format
 * @m24lr: Pointer to device control structure
 * @buf:   Input buffer containing hex-encoded password
 * @count: Number of bytes in @buf
 * @code:  Operation code to embed between password copies
 *
 * This function parses a 4-byte password, encodes it in  big-endian format,
 * and constructs a 9-byte sequence of the form:
 *
 *	  [BE(password), code, BE(password)]
 *
 * The result is written to register 0x0900 (2304), which is the password
 * register in M24LR04E-R chip.
 *
 * Return: Number of bytes written on success, or negative error code on failure
 */
static ssize_t m24lr_write_pass(struct m24lr *m24lr, const char *buf,
				size_t count, u8 code)
{
	__be32 be_pass;
	u8 output[9];
	ssize_t ret;
	u32 pass;
	int err;

	if (!count)
		return -EINVAL;

	if (count > 8)
		return -EINVAL;

	err = kstrtou32(buf, 16, &pass);
	if (err)
		return err;

	be_pass = cpu_to_be32(pass);

	memcpy(output, &be_pass, sizeof(be_pass));
	output[4] = code;
	memcpy(output + 5, &be_pass, sizeof(be_pass));

	mutex_lock(&m24lr->lock);
	ret = m24lr_regmap_write(m24lr->ctl_regmap, output, 9, 2304);
	mutex_unlock(&m24lr->lock);

	return ret;
}

static ssize_t m24lr_read_reg_le(struct m24lr *m24lr, u64 *val,
				 unsigned int reg_addr,
				 unsigned int reg_size)
{
	ssize_t ret;
	__le64 input = 0;

	ret = m24lr_read(m24lr, (u8 *)&input, reg_size, reg_addr, false);
	if (IS_ERR_VALUE(ret))
		return ret;

	if (ret != reg_size)
		return -EINVAL;

	switch (reg_size) {
	case 1:
		*val = *(u8 *)&input;
		break;
	case 2:
		*val = le16_to_cpu((__le16)input);
		break;
	case 4:
		*val = le32_to_cpu((__le32)input);
		break;
	case 8:
		*val = le64_to_cpu((__le64)input);
		break;
	default:
		return -EINVAL;
	}

	return 0;
}

static int m24lr_nvmem_read(void *priv, unsigned int offset, void *val,
			    size_t bytes)
{
	ssize_t err;
	struct m24lr *m24lr = priv;

	if (!bytes)
		return bytes;

	if (offset + bytes > m24lr->eeprom_size)
		return -EINVAL;

	err = m24lr_read(m24lr, val, bytes, offset, true);
	if (IS_ERR_VALUE(err))
		return err;

	return 0;
}

static int m24lr_nvmem_write(void *priv, unsigned int offset, void *val,
			     size_t bytes)
{
	ssize_t err;
	struct m24lr *m24lr = priv;

	if (!bytes)
		return -EINVAL;

	if (offset + bytes > m24lr->eeprom_size)
		return -EINVAL;

	err = m24lr_write(m24lr, val, bytes, offset, true);
	if (IS_ERR_VALUE(err))
		return err;

	return 0;
}

static ssize_t m24lr_ctl_sss_read(struct file *filep, struct kobject *kobj,
				  const struct bin_attribute *attr, char *buf,
				  loff_t offset, size_t count)
{
	struct m24lr *m24lr = attr->private;

	if (!count)
		return count;

	if (size_add(offset, count) > m24lr->sss_len)
		return -EINVAL;

	return m24lr_read(m24lr, buf, count, offset, false);
}

static ssize_t m24lr_ctl_sss_write(struct file *filep, struct kobject *kobj,
				   const struct bin_attribute *attr, char *buf,
				   loff_t offset, size_t count)
{
	struct m24lr *m24lr = attr->private;

	if (!count)
		return -EINVAL;

	if (size_add(offset, count) > m24lr->sss_len)
		return -EINVAL;

	return m24lr_write(m24lr, buf, count, offset, false);
}
static BIN_ATTR(sss, 0600, m24lr_ctl_sss_read, m24lr_ctl_sss_write, 0);

static ssize_t new_pass_store(struct device *dev, struct device_attribute *attr,
			      const char *buf, size_t count)
{
	struct m24lr *m24lr = i2c_get_clientdata(to_i2c_client(dev));

	return m24lr_write_pass(m24lr, buf, count, 7);
}
static DEVICE_ATTR_WO(new_pass);

static ssize_t unlock_store(struct device *dev, struct device_attribute *attr,
			    const char *buf, size_t count)
{
	struct m24lr *m24lr = i2c_get_clientdata(to_i2c_client(dev));

	return m24lr_write_pass(m24lr, buf, count, 9);
}
static DEVICE_ATTR_WO(unlock);

static ssize_t uid_show(struct device *dev, struct device_attribute *attr,
			char *buf)
{
	struct m24lr *m24lr = i2c_get_clientdata(to_i2c_client(dev));

	return sysfs_emit(buf, "%llx\n", m24lr->uid);
}
static DEVICE_ATTR_RO(uid);

static ssize_t total_sectors_show(struct device *dev,
				  struct device_attribute *attr, char *buf)
{
	struct m24lr *m24lr = i2c_get_clientdata(to_i2c_client(dev));

	return sysfs_emit(buf, "%x\n", m24lr->sss_len);
}
static DEVICE_ATTR_RO(total_sectors);

static struct attribute *m24lr_ctl_dev_attrs[] = {
	&dev_attr_unlock.attr,
	&dev_attr_new_pass.attr,
	&dev_attr_uid.attr,
	&dev_attr_total_sectors.attr,
	NULL,
};

static const struct m24lr_chip *m24lr_get_chip(struct device *dev)
{
	const struct m24lr_chip *ret;
	const struct i2c_device_id *id;

	id = i2c_match_id(m24lr_ids, to_i2c_client(dev));

	if (dev->of_node && of_match_device(m24lr_of_match, dev))
		ret = of_device_get_match_data(dev);
	else if (id)
		ret = (void *)id->driver_data;
	else
		ret = acpi_device_get_match_data(dev);

	return ret;
}

static int m24lr_probe(struct i2c_client *client)
{
	struct regmap_config eeprom_regmap_conf = {0};
	struct nvmem_config nvmem_conf = {0};
	struct device *dev = &client->dev;
	struct i2c_client *eeprom_client;
	const struct m24lr_chip *chip;
	struct regmap *eeprom_regmap;
	struct nvmem_device *nvmem;
	struct regmap *ctl_regmap;
	struct m24lr *m24lr;
	u32 regs[2];
	long err;

	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
		return -EOPNOTSUPP;

	chip = m24lr_get_chip(dev);
	if (!chip)
		return -ENODEV;

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

	err = device_property_read_u32_array(dev, "reg", regs, ARRAY_SIZE(regs));
	if (err)
		return dev_err_probe(dev, err, "Failed to read 'reg' property\n");

	/* Create a second I2C client for the eeprom interface */
	eeprom_client = devm_i2c_new_dummy_device(dev, client->adapter, regs[1]);
	if (IS_ERR(eeprom_client))
		return dev_err_probe(dev, PTR_ERR(eeprom_client),
				     "Failed to create dummy I2C client for the EEPROM\n");

	ctl_regmap = devm_regmap_init_i2c(client, &m24lr_ctl_regmap_conf);
	if (IS_ERR(ctl_regmap))
		return dev_err_probe(dev, PTR_ERR(ctl_regmap),
				      "Failed to init regmap\n");

	eeprom_regmap_conf.name = "m24lr_eeprom";
	eeprom_regmap_conf.reg_bits = 16;
	eeprom_regmap_conf.val_bits = 8;
	eeprom_regmap_conf.disable_locking = true;
	eeprom_regmap_conf.max_register = chip->eeprom_size - 1;

	eeprom_regmap = devm_regmap_init_i2c(eeprom_client,
					     &eeprom_regmap_conf);
	if (IS_ERR(eeprom_regmap))
		return dev_err_probe(dev, PTR_ERR(eeprom_regmap),
				     "Failed to init regmap\n");

	mutex_init(&m24lr->lock);
	m24lr->sss_len = chip->sss_len;
	m24lr->page_size = chip->page_size;
	m24lr->eeprom_size = chip->eeprom_size;
	m24lr->eeprom_regmap = eeprom_regmap;
	m24lr->ctl_regmap = ctl_regmap;

	nvmem_conf.dev = &eeprom_client->dev;
	nvmem_conf.owner = THIS_MODULE;
	nvmem_conf.type = NVMEM_TYPE_EEPROM;
	nvmem_conf.reg_read = m24lr_nvmem_read;
	nvmem_conf.reg_write = m24lr_nvmem_write;
	nvmem_conf.size = chip->eeprom_size;
	nvmem_conf.word_size = 1;
	nvmem_conf.stride = 1;
	nvmem_conf.priv = m24lr;

	nvmem = devm_nvmem_register(dev, &nvmem_conf);
	if (IS_ERR(nvmem))
		return dev_err_probe(dev, PTR_ERR(nvmem),
				     "Failed to register nvmem\n");

	i2c_set_clientdata(client, m24lr);
	i2c_set_clientdata(eeprom_client, m24lr);

	bin_attr_sss.size = chip->sss_len;
	bin_attr_sss.private = m24lr;
	err = sysfs_create_bin_file(&dev->kobj, &bin_attr_sss);
	if (err)
		return dev_err_probe(dev, err,
				     "Failed to create sss bin file\n");

	/* test by reading the uid, if success store it */
	err = m24lr_read_reg_le(m24lr, &m24lr->uid, 2324, sizeof(m24lr->uid));
	if (IS_ERR_VALUE(err))
		goto remove_bin_file;

	return 0;

remove_bin_file:
	sysfs_remove_bin_file(&dev->kobj, &bin_attr_sss);

	return err;
}

static void m24lr_remove(struct i2c_client *client)
{
	sysfs_remove_bin_file(&client->dev.kobj, &bin_attr_sss);
}

ATTRIBUTE_GROUPS(m24lr_ctl_dev);

static struct i2c_driver m24lr_driver = {
	.driver = {
		.name = "m24lr",
		.of_match_table = m24lr_of_match,
		.dev_groups = m24lr_ctl_dev_groups,
	},
	.probe	  = m24lr_probe,
	.remove = m24lr_remove,
	.id_table = m24lr_ids,
};
module_i2c_driver(m24lr_driver);

MODULE_AUTHOR("Abd-Alrhman Masalkhi");
MODULE_DESCRIPTION("st m24lr control driver");
MODULE_LICENSE("GPL");