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 v2:
- use a bitmap instead of lists of ranges.
---
drivers/nvmem/rmem.c | 195 +++++++++++++++++++++++++++++++++++++++++++
include/driver.h | 3 +
2 files changed, 198 insertions(+)
diff --git a/drivers/nvmem/rmem.c b/drivers/nvmem/rmem.c
index afa0dd78c8f4..fd7389cd39e3 100644
--- a/drivers/nvmem/rmem.c
+++ b/drivers/nvmem/rmem.c
@@ -11,6 +11,10 @@
struct rmem {
struct device *dev;
const struct resource *mem;
+ size_t total_size;
+ /* Bitmap: 1 bit per byte of rmem. 1=protected, 0=writable. */
+ unsigned char *protection_bitmap;
+ size_t protection_bitmap_bytes;
};
static int rmem_read(void *context, unsigned int offset,
@@ -21,6 +25,190 @@ static int rmem_read(void *context, unsigned int offset,
bytes, offset, 0);
}
+/**
+ * rmem_is_byte_protected() - Check if a specific byte is write-protected.
+ * @rmem: Pointer to the rmem private data.
+ * @offset: Offset of the byte to check.
+ *
+ * Helper function to consult the protection bitmap.
+ *
+ * Return: True if the byte at @offset is protected, false otherwise.
+ */
+static inline bool rmem_is_byte_protected(const struct rmem *rmem,
+ unsigned int offset)
+{
+ unsigned char bit_mask;
+ unsigned int byte_idx;
+
+ byte_idx = offset / 8;
+ bit_mask = 1U << (offset % 8);
+ return (rmem->protection_bitmap[byte_idx] & bit_mask) != 0;
+}
+
+/**
+ * rmem_do_protect_byte() - Mark a specific byte as write-protected.
+ * @rmem: Pointer to the rmem private data.
+ * @offset: Offset of the byte to protect.
+ *
+ * Helper function to set a bit in the protection bitmap. Assumes @offset
+ * is valid and rmem->protection_bitmap is allocated.
+ */
+static inline void rmem_do_protect_byte(struct rmem *rmem, unsigned int offset)
+{
+ unsigned char bit_mask = 1U << (offset % 8);
+ unsigned int byte_idx = offset / 8;
+
+ rmem->protection_bitmap[byte_idx] |= bit_mask;
+}
+
+/**
+ * rmem_do_unprotect_byte() - Mark a specific byte as writable.
+ * @rmem: Pointer to the rmem private data.
+ * @offset: Offset of the byte to unprotect.
+ *
+ * Helper function to clear a bit in the protection bitmap. Assumes @offset
+ * is valid and rmem->protection_bitmap is allocated.
+ */
+static inline void rmem_do_unprotect_byte(struct rmem *rmem,
+ unsigned int offset)
+{
+ unsigned int byte_idx = offset / 8;
+ unsigned char bit_mask = 1U << (offset % 8);
+
+ rmem->protection_bitmap[byte_idx] &= ~bit_mask;
+}
+
+/**
+ * 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.
+ * Specific error codes include -EROFS if protected or -EINVAL for bad params.
+ *
+ * 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)
+{
+ struct rmem *rmem = context;
+ unsigned int i;
+
+ for (i = 0; i < bytes; ++i) {
+ if (rmem_is_byte_protected(rmem, offset + i)) {
+ dev_warn(rmem->dev,
+ "Write [0x%x, len %zu] denied at 0x%x
(protected)\n",
+ offset, bytes, offset + i);
+ 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_set_protection_bits() - Mark a memory range as read-only.
+ * @rmem: Pointer to the rmem private data.
+ * @offset: Starting offset of the range to protect.
+ * @bytes: Length of the range to protect in bytes.
+ *
+ * Sets the corresponding bits in the protection_bitmap to mark the
+ * specified memory range as write-protected (read-only).
+ *
+ * Return: 0 on success, or a negative error code on failure.
+ */
+static int rmem_set_protection_bits(struct rmem *rmem, unsigned int offset,
+ size_t bytes)
+{
+ unsigned int end_offset = offset + bytes;
+ unsigned int i;
+
+ for (i = offset; i < end_offset; ++i)
+ rmem_do_protect_byte(rmem, i);
+
+ dev_info(rmem->dev, "Protected range [0x%x, len %zu]\n", offset,
+ bytes);
+ return 0;
+}
+
+/**
+ * rmem_clear_protection_bits() - Mark a memory range as writable.
+ * @rmem: Pointer to the rmem private data.
+ * @offset: Starting offset of the range to unprotect.
+ * @bytes: Length of the range to unprotect in bytes.
+ *
+ * Clears the corresponding bits in the protection_bitmap to mark the
+ * specified memory range as writable.
+ *
+ * Return: 0 on success, or a negative error code on failure.
+ */
+static int rmem_clear_protection_bits(struct rmem *rmem, unsigned int offset,
+ size_t bytes)
+{
+ unsigned int end_offset = offset + bytes;
+ unsigned int i;
+
+ for (i = offset; i < end_offset; ++i)
+ rmem_do_unprotect_byte(rmem, i);
+
+ dev_info(rmem->dev, "Unprotected range [0x%x, len %zu]\n", offset,
+ bytes);
+ return 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;
+
+ switch (prot_mode) {
+ case PROTECT_DISABLE_WRITE: /* Make read-only */
+ ret = rmem_set_protection_bits(rmem, offset, bytes);
+ break;
+ case PROTECT_ENABLE_WRITE: /* Make writable */
+ ret = rmem_clear_protection_bits(rmem, offset, bytes);
+ break;
+ default:
+ dev_warn(rmem->dev, "%s: Invalid protection mode %d\n",
+ __func__, prot_mode);
+ ret = -EINVAL;
+ break;
+ }
+
+ if (ret)
+ return ret;
+
+ 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 +229,14 @@ static int rmem_probe(struct device *dev)
config.priv = priv;
config.name = "rmem";
config.size = resource_size(mem);
+ priv->total_size = config.size;
+
+ priv->protection_bitmap_bytes = DIV_ROUND_UP(priv->total_size, 8);
+ priv->protection_bitmap = xzalloc(priv->protection_bitmap_bytes);
+
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 e9a919f9bbb5..8e738f076c30 100644
--- a/include/driver.h
+++ b/include/driver.h
@@ -431,6 +431,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
