Add reg_write and reg_protect operations to the rmem NVMEM driver.
This makes rmem devices writable (they were previously read-only via the
NVMEM interface due to lacking reg_write) and allows specific regions
to be marked read-only.
The primary motivation is to improve testing of NVMEM consumer code that
handles write protection, by enabling rmem to emulate such hardware,
particularly in sandbox environments.
Key changes:
- reg_write implemented: Enables writes. Writes to protected regions
return -EROFS.
- reg_protect implemented:
- PROTECT_DISABLE_WRITE: Marks range read-only.
- PROTECT_ENABLE_WRITE: Makes range writable.
- Probe function updated for new ops and list initialization.
Signed-off-by: Oleksij Rempel <o.rem...@pengutronix.de>
---
changes v3:
- use bitmap helpers
changes v2:
- use a bitmap instead of lists of ranges.
---
drivers/nvmem/rmem.c | 85 ++++++++++++++++++++++++++++++++++++++++++++
include/driver.h | 3 ++
2 files changed, 88 insertions(+)
diff --git a/drivers/nvmem/rmem.c b/drivers/nvmem/rmem.c
index afa0dd78c8f4..fd742b69861b 100644
--- a/drivers/nvmem/rmem.c
+++ b/drivers/nvmem/rmem.c
@@ -5,12 +5,15 @@
#include <io.h>
#include <driver.h>
+#include <linux/bitmap.h>
#include <linux/nvmem-provider.h>
#include <init.h>
struct rmem {
struct device *dev;
const struct resource *mem;
+ unsigned long *protection_bitmap;
+ size_t size;
};
static int rmem_read(void *context, unsigned int offset,
@@ -21,6 +24,82 @@ static int rmem_read(void *context, unsigned int offset,
bytes, offset, 0);
}
+/**
+ * rmem_write() - Write data to the NVMEM device.
+ * @context: Pointer to the rmem private data (struct rmem).
+ * @offset: Offset within the NVMEM device to write to.
+ * @val: Buffer containing the data to write.
+ * @bytes: Number of bytes to write.
+ *
+ * This function is called by the NVMEM core to write data to the
+ * reserved memory region. It first checks the protection bitmap to ensure
+ * the target range is not write-protected. If writable, it uses the
+ * custom 'mem_copy' function.
+ *
+ * Return: 0 on success, or a negative error code on failure.
+ */
+static int rmem_write(void *context, unsigned int offset, const void *val,
+ size_t bytes)
+{
+ unsigned long protected_offset;
+ struct rmem *rmem = context;
+
+ protected_offset = find_next_bit(rmem->protection_bitmap,
+ offset + bytes, offset);
+ if (protected_offset < offset + bytes)
+ return -EROFS;
+
+ /*
+ * The last two arguments to mem_copy (0, 0) are specific to
+ * the custom mem_copy implementation.
+ */
+ return mem_copy(rmem->dev, (void *)rmem->mem->start + offset, val,
+ bytes, 0, 0);
+}
+
+/**
+ * rmem_protect() - NVMEM callback to change protection status of a range.
+ * @context: Pointer to the rmem private data (struct rmem).
+ * @offset: Starting offset of the range.
+ * @bytes: Length of the range in bytes.
+ * @prot_mode: Protection mode to apply (PROTECT_DISABLE_WRITE or
+ * PROTECT_ENABLE_WRITE).
+ *
+ * This function is called by the NVMEM core to enable or disable
+ * write protection for a specified memory range.
+ *
+ * Return: 0 on success, or a negative error code on failure.
+ */
+static int rmem_protect(void *context, unsigned int offset, size_t bytes,
+ int prot_mode)
+{
+ struct rmem *rmem = context;
+ int ret;
+
+ if (offset + bytes > rmem->size)
+ return -EINVAL;
+
+ switch (prot_mode) {
+ case PROTECT_DISABLE_WRITE: /* Make read-only */
+ bitmap_set(rmem->protection_bitmap, offset, bytes);
+ break;
+ case PROTECT_ENABLE_WRITE: /* Make writable */
+ bitmap_clear(rmem->protection_bitmap, offset, bytes);
+ break;
+ default:
+ dev_warn(rmem->dev, "%s: Invalid protection mode %d\n",
+ __func__, prot_mode);
+ ret = -EINVAL;
+ break;
+ }
+
+ dev_dbg(rmem->dev,
+ "Protection op complete [0x%x, len %zu], mode %d\n", offset,
+ bytes, prot_mode);
+
+ return 0;
+}
+
static int rmem_probe(struct device *dev)
{
struct nvmem_config config = { };
@@ -41,7 +120,13 @@ static int rmem_probe(struct device *dev)
config.priv = priv;
config.name = "rmem";
config.size = resource_size(mem);
+ priv->size = config.size;
+
+ priv->protection_bitmap = bitmap_xzalloc(priv->size);
+
config.reg_read = rmem_read;
+ config.reg_write = rmem_write;
+ config.reg_protect = rmem_protect;
return PTR_ERR_OR_ZERO(nvmem_register(&config));
}
diff --git a/include/driver.h b/include/driver.h
index dd50a7aa3cce..8b62087a0c42 100644
--- a/include/driver.h
+++ b/include/driver.h
@@ -442,6 +442,9 @@ int platform_driver_register(struct driver *drv);
int platform_device_register(struct device *new_device);
+#define PROTECT_ENABLE_WRITE 0
+#define PROTECT_DISABLE_WRITE 1
+
struct cdev_operations {
/*! Called in response of reading from this device. Required */
ssize_t (*read)(struct cdev*, void* buf, size_t count, loff_t offset,
ulong flags);
--
2.39.5
