233 lines · c
1// SPDX-License-Identifier: GPL-2.0+2/*3 * Allwinner sunXi SoCs Security ID support.4 *5 * Copyright (c) 2013 Oliver Schinagl <oliver@schinagl.nl>6 * Copyright (C) 2014 Maxime Ripard <maxime.ripard@free-electrons.com>7 */8 9#include <linux/device.h>10#include <linux/io.h>11#include <linux/iopoll.h>12#include <linux/module.h>13#include <linux/nvmem-provider.h>14#include <linux/of.h>15#include <linux/platform_device.h>16#include <linux/slab.h>17#include <linux/random.h>18 19/* Registers and special values for doing register-based SID readout on H3 */20#define SUN8I_SID_PRCTL 0x4021#define SUN8I_SID_RDKEY 0x6022 23#define SUN8I_SID_OFFSET_MASK 0x1FF24#define SUN8I_SID_OFFSET_SHIFT 1625#define SUN8I_SID_OP_LOCK (0xAC << 8)26#define SUN8I_SID_READ BIT(1)27 28struct sunxi_sid_cfg {29 u32 value_offset;30 u32 size;31 bool need_register_readout;32};33 34struct sunxi_sid {35 void __iomem *base;36 u32 value_offset;37};38 39static int sunxi_sid_read(void *context, unsigned int offset,40 void *val, size_t bytes)41{42 struct sunxi_sid *sid = context;43 u32 word;44 45 /* .stride = 4 so offset is guaranteed to be aligned */46 __ioread32_copy(val, sid->base + sid->value_offset + offset, bytes / 4);47 48 val += round_down(bytes, 4);49 offset += round_down(bytes, 4);50 bytes = bytes % 4;51 52 if (!bytes)53 return 0;54 55 /* Handle any trailing bytes */56 word = readl_relaxed(sid->base + sid->value_offset + offset);57 memcpy(val, &word, bytes);58 59 return 0;60}61 62static int sun8i_sid_register_readout(const struct sunxi_sid *sid,63 const unsigned int offset,64 u32 *out)65{66 u32 reg_val;67 int ret;68 69 /* Set word, lock access, and set read command */70 reg_val = (offset & SUN8I_SID_OFFSET_MASK)71 << SUN8I_SID_OFFSET_SHIFT;72 reg_val |= SUN8I_SID_OP_LOCK | SUN8I_SID_READ;73 writel(reg_val, sid->base + SUN8I_SID_PRCTL);74 75 ret = readl_poll_timeout(sid->base + SUN8I_SID_PRCTL, reg_val,76 !(reg_val & SUN8I_SID_READ), 100, 250000);77 if (ret)78 return ret;79 80 if (out)81 *out = readl(sid->base + SUN8I_SID_RDKEY);82 83 writel(0, sid->base + SUN8I_SID_PRCTL);84 85 return 0;86}87 88/*89 * On Allwinner H3, the value on the 0x200 offset of the SID controller seems90 * to be not reliable at all.91 * Read by the registers instead.92 */93static int sun8i_sid_read_by_reg(void *context, unsigned int offset,94 void *val, size_t bytes)95{96 struct sunxi_sid *sid = context;97 u32 word;98 int ret;99 100 /* .stride = 4 so offset is guaranteed to be aligned */101 while (bytes >= 4) {102 ret = sun8i_sid_register_readout(sid, offset, val);103 if (ret)104 return ret;105 106 val += 4;107 offset += 4;108 bytes -= 4;109 }110 111 if (!bytes)112 return 0;113 114 /* Handle any trailing bytes */115 ret = sun8i_sid_register_readout(sid, offset, &word);116 if (ret)117 return ret;118 119 memcpy(val, &word, bytes);120 121 return 0;122}123 124static int sunxi_sid_probe(struct platform_device *pdev)125{126 struct device *dev = &pdev->dev;127 struct nvmem_config *nvmem_cfg;128 struct nvmem_device *nvmem;129 struct sunxi_sid *sid;130 int size;131 char *randomness;132 const struct sunxi_sid_cfg *cfg;133 134 sid = devm_kzalloc(dev, sizeof(*sid), GFP_KERNEL);135 if (!sid)136 return -ENOMEM;137 138 cfg = of_device_get_match_data(dev);139 if (!cfg)140 return -EINVAL;141 sid->value_offset = cfg->value_offset;142 143 sid->base = devm_platform_ioremap_resource(pdev, 0);144 if (IS_ERR(sid->base))145 return PTR_ERR(sid->base);146 147 size = cfg->size;148 149 nvmem_cfg = devm_kzalloc(dev, sizeof(*nvmem_cfg), GFP_KERNEL);150 if (!nvmem_cfg)151 return -ENOMEM;152 153 nvmem_cfg->dev = dev;154 nvmem_cfg->name = "sunxi-sid";155 nvmem_cfg->type = NVMEM_TYPE_OTP;156 nvmem_cfg->add_legacy_fixed_of_cells = true;157 nvmem_cfg->read_only = true;158 nvmem_cfg->size = cfg->size;159 nvmem_cfg->word_size = 1;160 nvmem_cfg->stride = 4;161 nvmem_cfg->priv = sid;162 if (cfg->need_register_readout)163 nvmem_cfg->reg_read = sun8i_sid_read_by_reg;164 else165 nvmem_cfg->reg_read = sunxi_sid_read;166 167 nvmem = devm_nvmem_register(dev, nvmem_cfg);168 if (IS_ERR(nvmem))169 return PTR_ERR(nvmem);170 171 randomness = kzalloc(size, GFP_KERNEL);172 if (!randomness)173 return -ENOMEM;174 175 nvmem_cfg->reg_read(sid, 0, randomness, size);176 add_device_randomness(randomness, size);177 kfree(randomness);178 179 platform_set_drvdata(pdev, nvmem);180 181 return 0;182}183 184static const struct sunxi_sid_cfg sun4i_a10_cfg = {185 .size = 0x10,186};187 188static const struct sunxi_sid_cfg sun7i_a20_cfg = {189 .size = 0x200,190};191 192static const struct sunxi_sid_cfg sun8i_h3_cfg = {193 .value_offset = 0x200,194 .size = 0x100,195 .need_register_readout = true,196};197 198static const struct sunxi_sid_cfg sun50i_a64_cfg = {199 .value_offset = 0x200,200 .size = 0x100,201};202 203static const struct sunxi_sid_cfg sun50i_h6_cfg = {204 .value_offset = 0x200,205 .size = 0x200,206};207 208static const struct of_device_id sunxi_sid_of_match[] = {209 { .compatible = "allwinner,sun4i-a10-sid", .data = &sun4i_a10_cfg },210 { .compatible = "allwinner,sun7i-a20-sid", .data = &sun7i_a20_cfg },211 { .compatible = "allwinner,sun8i-a83t-sid", .data = &sun50i_a64_cfg },212 { .compatible = "allwinner,sun8i-h3-sid", .data = &sun8i_h3_cfg },213 { .compatible = "allwinner,sun20i-d1-sid", .data = &sun50i_a64_cfg },214 { .compatible = "allwinner,sun50i-a64-sid", .data = &sun50i_a64_cfg },215 { .compatible = "allwinner,sun50i-h5-sid", .data = &sun50i_a64_cfg },216 { .compatible = "allwinner,sun50i-h6-sid", .data = &sun50i_h6_cfg },217 {/* sentinel */},218};219MODULE_DEVICE_TABLE(of, sunxi_sid_of_match);220 221static struct platform_driver sunxi_sid_driver = {222 .probe = sunxi_sid_probe,223 .driver = {224 .name = "eeprom-sunxi-sid",225 .of_match_table = sunxi_sid_of_match,226 },227};228module_platform_driver(sunxi_sid_driver);229 230MODULE_AUTHOR("Oliver Schinagl <oliver@schinagl.nl>");231MODULE_DESCRIPTION("Allwinner sunxi security id driver");232MODULE_LICENSE("GPL");233