rockchip-efuse.c 7.58 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0-only
2 3 4 5 6 7 8
/*
 * Rockchip eFuse Driver
 *
 * Copyright (c) 2015 Rockchip Electronics Co. Ltd.
 * Author: Caesar Wang <wxt@rock-chips.com>
 */

9 10
#include <linux/clk.h>
#include <linux/delay.h>
11 12 13
#include <linux/device.h>
#include <linux/io.h>
#include <linux/module.h>
14 15
#include <linux/nvmem-provider.h>
#include <linux/slab.h>
16
#include <linux/of.h>
17
#include <linux/of_platform.h>
18
#include <linux/platform_device.h>
19

20 21 22 23 24 25 26
#define RK3288_A_SHIFT		6
#define RK3288_A_MASK		0x3ff
#define RK3288_PGENB		BIT(3)
#define RK3288_LOAD		BIT(2)
#define RK3288_STROBE		BIT(1)
#define RK3288_CSB		BIT(0)

27 28 29 30 31 32 33 34
#define RK3328_SECURE_SIZES	96
#define RK3328_INT_STATUS	0x0018
#define RK3328_DOUT		0x0020
#define RK3328_AUTO_CTRL	0x0024
#define RK3328_INT_FINISH	BIT(0)
#define RK3328_AUTO_ENB		BIT(0)
#define RK3328_AUTO_RD		BIT(1)

35 36 37 38 39 40 41 42 43 44 45 46 47
#define RK3399_A_SHIFT		16
#define RK3399_A_MASK		0x3ff
#define RK3399_NBYTES		4
#define RK3399_STROBSFTSEL	BIT(9)
#define RK3399_RSB		BIT(7)
#define RK3399_PD		BIT(5)
#define RK3399_PGENB		BIT(3)
#define RK3399_LOAD		BIT(2)
#define RK3399_STROBE		BIT(1)
#define RK3399_CSB		BIT(0)

#define REG_EFUSE_CTRL		0x0000
#define REG_EFUSE_DOUT		0x0004
48

49
struct rockchip_efuse_chip {
50 51
	struct device *dev;
	void __iomem *base;
52
	struct clk *clk;
53 54
};

55 56
static int rockchip_rk3288_efuse_read(void *context, unsigned int offset,
				      void *val, size_t bytes)
57
{
58
	struct rockchip_efuse_chip *efuse = context;
59 60 61
	u8 *buf = val;
	int ret;

62
	ret = clk_prepare_enable(efuse->clk);
63
	if (ret < 0) {
64
		dev_err(efuse->dev, "failed to prepare/enable efuse clk\n");
65 66 67
		return ret;
	}

68
	writel(RK3288_LOAD | RK3288_PGENB, efuse->base + REG_EFUSE_CTRL);
69
	udelay(1);
70
	while (bytes--) {
71
		writel(readl(efuse->base + REG_EFUSE_CTRL) &
72
			     (~(RK3288_A_MASK << RK3288_A_SHIFT)),
73 74
			     efuse->base + REG_EFUSE_CTRL);
		writel(readl(efuse->base + REG_EFUSE_CTRL) |
75
			     ((offset++ & RK3288_A_MASK) << RK3288_A_SHIFT),
76
			     efuse->base + REG_EFUSE_CTRL);
77
		udelay(1);
78
		writel(readl(efuse->base + REG_EFUSE_CTRL) |
79
			     RK3288_STROBE, efuse->base + REG_EFUSE_CTRL);
80
		udelay(1);
81 82
		*buf++ = readb(efuse->base + REG_EFUSE_DOUT);
		writel(readl(efuse->base + REG_EFUSE_CTRL) &
83 84 85 86 87 88 89 90 91 92 93 94
		       (~RK3288_STROBE), efuse->base + REG_EFUSE_CTRL);
		udelay(1);
	}

	/* Switch to standby mode */
	writel(RK3288_PGENB | RK3288_CSB, efuse->base + REG_EFUSE_CTRL);

	clk_disable_unprepare(efuse->clk);

	return 0;
}

95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116
static int rockchip_rk3328_efuse_read(void *context, unsigned int offset,
				      void *val, size_t bytes)
{
	struct rockchip_efuse_chip *efuse = context;
	unsigned int addr_start, addr_end, addr_offset, addr_len;
	u32 out_value, status;
	u8 *buf;
	int ret, i = 0;

	ret = clk_prepare_enable(efuse->clk);
	if (ret < 0) {
		dev_err(efuse->dev, "failed to prepare/enable efuse clk\n");
		return ret;
	}

	/* 128 Byte efuse, 96 Byte for secure, 32 Byte for non-secure */
	offset += RK3328_SECURE_SIZES;
	addr_start = rounddown(offset, RK3399_NBYTES) / RK3399_NBYTES;
	addr_end = roundup(offset + bytes, RK3399_NBYTES) / RK3399_NBYTES;
	addr_offset = offset % RK3399_NBYTES;
	addr_len = addr_end - addr_start;

117 118
	buf = kzalloc(array3_size(addr_len, RK3399_NBYTES, sizeof(*buf)),
		      GFP_KERNEL);
119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149
	if (!buf) {
		ret = -ENOMEM;
		goto nomem;
	}

	while (addr_len--) {
		writel(RK3328_AUTO_RD | RK3328_AUTO_ENB |
		       ((addr_start++ & RK3399_A_MASK) << RK3399_A_SHIFT),
		       efuse->base + RK3328_AUTO_CTRL);
		udelay(4);
		status = readl(efuse->base + RK3328_INT_STATUS);
		if (!(status & RK3328_INT_FINISH)) {
			ret = -EIO;
			goto err;
		}
		out_value = readl(efuse->base + RK3328_DOUT);
		writel(RK3328_INT_FINISH, efuse->base + RK3328_INT_STATUS);

		memcpy(&buf[i], &out_value, RK3399_NBYTES);
		i += RK3399_NBYTES;
	}

	memcpy(val, buf + addr_offset, bytes);
err:
	kfree(buf);
nomem:
	clk_disable_unprepare(efuse->clk);

	return ret;
}

150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169
static int rockchip_rk3399_efuse_read(void *context, unsigned int offset,
				      void *val, size_t bytes)
{
	struct rockchip_efuse_chip *efuse = context;
	unsigned int addr_start, addr_end, addr_offset, addr_len;
	u32 out_value;
	u8 *buf;
	int ret, i = 0;

	ret = clk_prepare_enable(efuse->clk);
	if (ret < 0) {
		dev_err(efuse->dev, "failed to prepare/enable efuse clk\n");
		return ret;
	}

	addr_start = rounddown(offset, RK3399_NBYTES) / RK3399_NBYTES;
	addr_end = roundup(offset + bytes, RK3399_NBYTES) / RK3399_NBYTES;
	addr_offset = offset % RK3399_NBYTES;
	addr_len = addr_end - addr_start;

170 171
	buf = kzalloc(array3_size(addr_len, RK3399_NBYTES, sizeof(*buf)),
		      GFP_KERNEL);
172 173 174 175 176 177 178 179 180 181 182 183
	if (!buf) {
		clk_disable_unprepare(efuse->clk);
		return -ENOMEM;
	}

	writel(RK3399_LOAD | RK3399_PGENB | RK3399_STROBSFTSEL | RK3399_RSB,
	       efuse->base + REG_EFUSE_CTRL);
	udelay(1);
	while (addr_len--) {
		writel(readl(efuse->base + REG_EFUSE_CTRL) | RK3399_STROBE |
		       ((addr_start++ & RK3399_A_MASK) << RK3399_A_SHIFT),
		       efuse->base + REG_EFUSE_CTRL);
184
		udelay(1);
185 186 187 188 189 190 191
		out_value = readl(efuse->base + REG_EFUSE_DOUT);
		writel(readl(efuse->base + REG_EFUSE_CTRL) & (~RK3399_STROBE),
		       efuse->base + REG_EFUSE_CTRL);
		udelay(1);

		memcpy(&buf[i], &out_value, RK3399_NBYTES);
		i += RK3399_NBYTES;
192 193 194
	}

	/* Switch to standby mode */
195 196 197 198 199
	writel(RK3399_PD | RK3399_CSB, efuse->base + REG_EFUSE_CTRL);

	memcpy(val, buf + addr_offset, bytes);

	kfree(buf);
200

201
	clk_disable_unprepare(efuse->clk);
202 203 204 205 206 207

	return 0;
}

static struct nvmem_config econfig = {
	.name = "rockchip-efuse",
208 209
	.stride = 1,
	.word_size = 1,
210 211 212 213
	.read_only = true,
};

static const struct of_device_id rockchip_efuse_match[] = {
214 215 216 217 218 219 220 221 222 223 224 225 226
	/* deprecated but kept around for dts binding compatibility */
	{
		.compatible = "rockchip,rockchip-efuse",
		.data = (void *)&rockchip_rk3288_efuse_read,
	},
	{
		.compatible = "rockchip,rk3066a-efuse",
		.data = (void *)&rockchip_rk3288_efuse_read,
	},
	{
		.compatible = "rockchip,rk3188-efuse",
		.data = (void *)&rockchip_rk3288_efuse_read,
	},
227
	{
228
		.compatible = "rockchip,rk3228-efuse",
229 230
		.data = (void *)&rockchip_rk3288_efuse_read,
	},
231 232 233 234
	{
		.compatible = "rockchip,rk3288-efuse",
		.data = (void *)&rockchip_rk3288_efuse_read,
	},
235 236 237 238
	{
		.compatible = "rockchip,rk3368-efuse",
		.data = (void *)&rockchip_rk3288_efuse_read,
	},
239 240 241 242
	{
		.compatible = "rockchip,rk3328-efuse",
		.data = (void *)&rockchip_rk3328_efuse_read,
	},
243 244 245 246
	{
		.compatible = "rockchip,rk3399-efuse",
		.data = (void *)&rockchip_rk3399_efuse_read,
	},
247 248 249 250
	{ /* sentinel */},
};
MODULE_DEVICE_TABLE(of, rockchip_efuse_match);

251
static int rockchip_efuse_probe(struct platform_device *pdev)
252 253 254
{
	struct resource *res;
	struct nvmem_device *nvmem;
255
	struct rockchip_efuse_chip *efuse;
256
	const void *data;
257 258
	struct device *dev = &pdev->dev;

259 260
	data = of_device_get_match_data(dev);
	if (!data) {
261 262 263
		dev_err(dev, "failed to get match data\n");
		return -EINVAL;
	}
264

265
	efuse = devm_kzalloc(dev, sizeof(struct rockchip_efuse_chip),
266 267 268
			     GFP_KERNEL);
	if (!efuse)
		return -ENOMEM;
269

270
	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
271
	efuse->base = devm_ioremap_resource(dev, res);
272 273
	if (IS_ERR(efuse->base))
		return PTR_ERR(efuse->base);
274

275
	efuse->clk = devm_clk_get(dev, "pclk_efuse");
276 277
	if (IS_ERR(efuse->clk))
		return PTR_ERR(efuse->clk);
278

279
	efuse->dev = dev;
280 281 282
	if (of_property_read_u32(dev->of_node, "rockchip,efuse-size",
				 &econfig.size))
		econfig.size = resource_size(res);
283
	econfig.reg_read = data;
284
	econfig.priv = efuse;
285
	econfig.dev = efuse->dev;
286
	nvmem = devm_nvmem_register(dev, &econfig);
287

288
	return PTR_ERR_OR_ZERO(nvmem);
289 290 291 292 293 294 295 296 297 298 299 300 301
}

static struct platform_driver rockchip_efuse_driver = {
	.probe = rockchip_efuse_probe,
	.driver = {
		.name = "rockchip-efuse",
		.of_match_table = rockchip_efuse_match,
	},
};

module_platform_driver(rockchip_efuse_driver);
MODULE_DESCRIPTION("rockchip_efuse driver");
MODULE_LICENSE("GPL v2");