Commit 1530b923 authored by Geert Uytterhoeven's avatar Geert Uytterhoeven Committed by Greg Kroah-Hartman
Browse files

nvmem: Add R-Car E-FUSE driver 



R-Car Gen4 SoCs contain fuses indicating hardware support or hardware
(e.g. tuning) parameters.  Add a driver to access the state of the
fuses.  This supports two types of hardware fuse providers:
  1. E-FUSE non-volatile memory accessible through the Pin Function
     Controller on R-Car V3U and S4-8,
  2. E-FUSE non-volatile memory accessible through OTP_MEM on R-Car V4H
     and V4M.

The state of the cells can be read using the NVMEM framework, either
from kernel space (e.g. by the Renesas UFSHCD driver), or from
userspace.

Signed-off-by: default avatarGeert Uytterhoeven <geert+renesas@glider.be>
Reviewed-by: default avatarYoshihiro Shimoda <yoshihiro.shimoda.uh@renesas.com>
Acked-by: default avatarArnd Bergmann <arnd@arndb.de>
Signed-off-by: default avatarSrinivas Kandagatla <srinivas.kandagatla@linaro.org>
Link: https://lore.kernel.org/r/20241030140315.40562-3-srinivas.kandagatla@linaro.org


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

MAINTAINERS

+1 −0
Original line number Diff line number Diff line
@@ -2930,6 +2930,7 @@ F: arch/arm/include/debug/renesas-scif.S 
F:	arch/arm/mach-shmobile/

F:	arch/arm64/boot/dts/renesas/

F:	arch/riscv/boot/dts/renesas/

F:	drivers/nvmem/rcar-efuse.c

F:	drivers/pmdomain/renesas/

F:	drivers/soc/renesas/

F:	include/linux/soc/renesas/

drivers/nvmem/Kconfig

+11 −0
Original line number Diff line number Diff line
@@ -246,6 +246,17 @@ config NVMEM_RAVE_SP_EEPROM 
	help

	  Say y here to enable Rave SP EEPROM support.



config NVMEM_RCAR_EFUSE

	tristate "Renesas R-Car Gen4 E-FUSE support"

	depends on (ARCH_RENESAS && ARM64) || COMPILE_TEST

	depends on NVMEM

	help

	  Enable support for reading the fuses in the E-FUSE or OTP

	  non-volatile memory block on Renesas R-Car Gen4 SoCs.



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

	  will be called nvmem-rcar-efuse.



config NVMEM_RMEM

	tristate "Reserved Memory Based Driver Support"

	depends on HAS_IOMEM

drivers/nvmem/Makefile

+2 −0
Original line number Diff line number Diff line
@@ -52,6 +52,8 @@ obj-$(CONFIG_NVMEM_QCOM_SEC_QFPROM) += nvmem_sec_qfprom.o 
nvmem_sec_qfprom-y			:= sec-qfprom.o

obj-$(CONFIG_NVMEM_RAVE_SP_EEPROM)	+= nvmem-rave-sp-eeprom.o

nvmem-rave-sp-eeprom-y			:= rave-sp-eeprom.o

obj-$(CONFIG_NVMEM_RCAR_EFUSE)		+= nvmem-rcar-efuse.o

nvmem-rcar-efuse-y			:= rcar-efuse.o

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

nvmem-rmem-y				:= rmem.o

obj-$(CONFIG_NVMEM_ROCKCHIP_EFUSE)	+= nvmem_rockchip_efuse.o

drivers/nvmem/rcar-efuse.c

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

/*

 * Renesas R-Car E-FUSE/OTP Driver

 *

 * Copyright (C) 2024 Glider bv

 */



#include <linux/device.h>

#include <linux/export.h>

#include <linux/io.h>

#include <linux/mod_devicetable.h>

#include <linux/nvmem-provider.h>

#include <linux/platform_device.h>

#include <linux/pm_runtime.h>

#include <linux/property.h>



struct rcar_fuse {

	struct nvmem_keepout keepouts[2];

	struct nvmem_device *nvmem;

	struct device *dev;

	void __iomem *base;

};



struct rcar_fuse_data {

	unsigned int bank;	/* 0: PFC + E-FUSE, 1: OPT_MEM + E-FUSE */

	unsigned int start;	/* inclusive */

	unsigned int end;	/* exclusive */

};



static int rcar_fuse_reg_read(void *priv, unsigned int offset, void *val,

			      size_t bytes)

{

	struct rcar_fuse *fuse = priv;

	int ret;



	ret = pm_runtime_resume_and_get(fuse->dev);

	if (ret < 0)

		return ret;



	__ioread32_copy(val, fuse->base + offset, bytes / 4);



	pm_runtime_put(fuse->dev);



	return 0;

}



static int rcar_fuse_probe(struct platform_device *pdev)

{

	struct device *dev = &pdev->dev;

	const struct rcar_fuse_data *data = device_get_match_data(dev);

	struct nvmem_config config = {

		.dev = dev,

		.name = "rcar-fuse",

		.id = NVMEM_DEVID_NONE,

		.owner = THIS_MODULE,

		.type = NVMEM_TYPE_OTP,

		.read_only = true,

		.root_only = true,

		.reg_read = rcar_fuse_reg_read,

		.word_size = 4,

		.stride = 4,

	};

	struct rcar_fuse *fuse;

	struct resource *res;

	int ret;



	ret = devm_pm_runtime_enable(dev);

	if (ret < 0)

		return ret;



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

	if (!fuse)

		return -ENOMEM;



	fuse->base = devm_platform_get_and_ioremap_resource(pdev, data->bank,

							    &res);

	if (IS_ERR(fuse->base))

		return PTR_ERR(fuse->base);



	fuse->dev = dev;

	fuse->keepouts[0].start = 0;

	fuse->keepouts[0].end = data->start;

	fuse->keepouts[1].start = data->end;

	fuse->keepouts[1].end = resource_size(res);



	config.keepout = fuse->keepouts;

	config.nkeepout = ARRAY_SIZE(fuse->keepouts);

	config.size = resource_size(res);

	config.priv = fuse;



	fuse->nvmem = devm_nvmem_register(dev, &config);

	if (IS_ERR(fuse->nvmem))

		return dev_err_probe(dev, PTR_ERR(fuse->nvmem),

				     "Failed to register NVMEM device\n");



	return 0;

}



static const struct rcar_fuse_data rcar_fuse_v3u = {

	.bank = 0,

	.start = 0x0c0,

	.end = 0x0e8,

};



static const struct rcar_fuse_data rcar_fuse_s4 = {

	.bank = 0,

	.start = 0x0c0,

	.end = 0x14c,

};



static const struct rcar_fuse_data rcar_fuse_v4h = {

	.bank = 1,

	.start = 0x100,

	.end = 0x1a0,

};



static const struct rcar_fuse_data rcar_fuse_v4m = {

	.bank = 1,

	.start = 0x100,

	.end = 0x110,

};



static const struct of_device_id rcar_fuse_match[] = {

	{ .compatible = "renesas,r8a779a0-efuse", .data = &rcar_fuse_v3u },

	{ .compatible = "renesas,r8a779f0-efuse", .data = &rcar_fuse_s4 },

	{ .compatible = "renesas,r8a779g0-otp", .data = &rcar_fuse_v4h },

	{ .compatible = "renesas,r8a779h0-otp", .data = &rcar_fuse_v4m },

	{ /* sentinel */ }

};



static struct platform_driver rcar_fuse_driver = {

	.probe = rcar_fuse_probe,

	.driver = {

		.name = "rcar_fuse",

		.of_match_table = rcar_fuse_match,

	},

};

module_platform_driver(rcar_fuse_driver);



MODULE_DESCRIPTION("Renesas R-Car E-FUSE/OTP driver");

MODULE_LICENSE("GPL");

MODULE_AUTHOR("Geert Uytterhoeven");