Commit 5a3fa75a authored by Nicolas Saenz Julienne's avatar Nicolas Saenz Julienne Committed by Greg Kroah-Hartman
Browse files

nvmem: Add driver to expose reserved memory as nvmem 



Firmware/co-processors might use reserved memory areas in order to pass
data stemming from an nvmem device otherwise non accessible to Linux.
For example an EEPROM memory only physically accessible to firmware, or
data only accessible early at boot time.

In order to expose this data to other drivers and user-space, the driver
models the reserved memory area as an nvmem device.

Tested-by: default avatarTim Gover <tim.gover@raspberrypi.com>
Reviewed-by: default avatarRob Herring <robh@kernel.org>
Signed-off-by: default avatarNicolas Saenz Julienne <nsaenzjulienne@suse.de>
Signed-off-by: default avatarSrinivas Kandagatla <srinivas.kandagatla@linaro.org>
Link: https://lore.kernel.org/r/20210129171430.11328-5-srinivas.kandagatla@linaro.org


Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent f90714e5

drivers/nvmem/Kconfig

+8 −0
Original line number Diff line number Diff line
@@ -270,4 +270,12 @@ config SPRD_EFUSE 
	  This driver can also be built as a module. If so, the module

	  will be called nvmem-sprd-efuse.



config NVMEM_RMEM

	tristate "Reserved Memory Based Driver Support"

	help

	  This drivers maps reserved memory into an nvmem device. It might be

	  useful to expose information left by firmware in memory.



	  This driver can also be built as a module. If so, the module

	  will be called nvmem-rmem.

endif

drivers/nvmem/Makefile

+2 −0
Original line number Diff line number Diff line
@@ -55,3 +55,5 @@ obj-$(CONFIG_NVMEM_ZYNQMP) += nvmem_zynqmp_nvmem.o 
nvmem_zynqmp_nvmem-y		:= zynqmp_nvmem.o

obj-$(CONFIG_SPRD_EFUSE)	+= nvmem_sprd_efuse.o

nvmem_sprd_efuse-y		:= sprd-efuse.o

obj-$(CONFIG_NVMEM_RMEM) 	+= nvmem-rmem.o

nvmem-rmem-y			:= rmem.o

drivers/nvmem/rmem.c

0 → 100644
+97 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0+

/*

 * Copyright (C) 2020 Nicolas Saenz Julienne <nsaenzjulienne@suse.de>

 */



#include <linux/io.h>

#include <linux/module.h>

#include <linux/nvmem-provider.h>

#include <linux/of_reserved_mem.h>

#include <linux/platform_device.h>



struct rmem {

	struct device *dev;

	struct nvmem_device *nvmem;

	struct reserved_mem *mem;



	phys_addr_t size;

};



static int rmem_read(void *context, unsigned int offset,

		     void *val, size_t bytes)

{

	struct rmem *priv = context;

	size_t available = priv->mem->size;

	loff_t off = offset;

	void *addr;

	int count;



	/*

	 * Only map the reserved memory at this point to avoid potential rogue

	 * kernel threads inadvertently modifying it. Based on the current

	 * uses-cases for this driver, the performance hit isn't a concern.

	 * Nor is likely to be, given the nature of the subsystem. Most nvmem

	 * devices operate over slow buses to begin with.

	 *

	 * An alternative would be setting the memory as RO, set_memory_ro(),

	 * but as of Dec 2020 this isn't possible on arm64.

	 */

	addr = memremap(priv->mem->base, available, MEMREMAP_WB);

	if (IS_ERR(addr)) {

		dev_err(priv->dev, "Failed to remap memory region\n");

		return PTR_ERR(addr);

	}



	count = memory_read_from_buffer(val, bytes, &off, addr, available);



	memunmap(addr);



	return count;

}



static int rmem_probe(struct platform_device *pdev)

{

	struct nvmem_config config = { };

	struct device *dev = &pdev->dev;

	struct reserved_mem *mem;

	struct rmem *priv;



	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);

	if (!priv)

		return -ENOMEM;

	priv->dev = dev;



	mem = of_reserved_mem_lookup(dev->of_node);

	if (!mem) {

		dev_err(dev, "Failed to lookup reserved memory\n");

		return -EINVAL;

	}

	priv->mem = mem;



	config.dev = dev;

	config.priv = priv;

	config.name = "rmem";

	config.size = mem->size;

	config.reg_read = rmem_read;



	return PTR_ERR_OR_ZERO(devm_nvmem_register(dev, &config));

}



static const struct of_device_id rmem_match[] = {

	{ .compatible = "nvmem-rmem", },

	{ /* sentinel */ },

};

MODULE_DEVICE_TABLE(of, rmem_match);



static struct platform_driver rmem_driver = {

	.probe = rmem_probe,

	.driver = {

		.name = "rmem",

		.of_match_table = rmem_match,

	},

};

module_platform_driver(rmem_driver);



MODULE_AUTHOR("Nicolas Saenz Julienne <nsaenzjulienne@suse.de>");

MODULE_DESCRIPTION("Reserved Memory Based nvmem Driver");

MODULE_LICENSE("GPL");

drivers/of/platform.c

+1 −0
Original line number Diff line number Diff line
@@ -511,6 +511,7 @@ static const struct of_device_id reserved_mem_matches[] = { 
	{ .compatible = "qcom,rmtfs-mem" },

	{ .compatible = "qcom,cmd-db" },

	{ .compatible = "ramoops" },

	{ .compatible = "nvmem-rmem" },

	{}

};