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 0x40 21 #define SUN8I_SID_RDKEY 0x60 22 23 #define SUN8I_SID_OFFSET_MASK 0x1FF 24 #define SUN8I_SID_OFFSET_SHIFT 16 25 #define SUN8I_SID_OP_LOCK (0xAC << 8) 26 #define SUN8I_SID_READ BIT(1) 27 28 struct sunxi_sid_cfg { 29 u32 value_offset; 30 u32 size; 31 bool need_register_readout; 32 }; 33 34 struct sunxi_sid { 35 void __iomem *base; 36 u32 value_offset; 37 }; 38 39 static 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 62 static 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 seems 90 * to be not reliable at all. 91 * Read by the registers instead. 92 */ 93 static 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 124 static 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->read_only = true; 157 nvmem_cfg->size = cfg->size; 158 nvmem_cfg->word_size = 1; 159 nvmem_cfg->stride = 4; 160 nvmem_cfg->priv = sid; 161 if (cfg->need_register_readout) 162 nvmem_cfg->reg_read = sun8i_sid_read_by_reg; 163 else 164 nvmem_cfg->reg_read = sunxi_sid_read; 165 166 nvmem = devm_nvmem_register(dev, nvmem_cfg); 167 if (IS_ERR(nvmem)) 168 return PTR_ERR(nvmem); 169 170 randomness = kzalloc(size, GFP_KERNEL); 171 if (!randomness) 172 return -ENOMEM; 173 174 nvmem_cfg->reg_read(sid, 0, randomness, size); 175 add_device_randomness(randomness, size); 176 kfree(randomness); 177 178 platform_set_drvdata(pdev, nvmem); 179 180 return 0; 181 } 182 183 static const struct sunxi_sid_cfg sun4i_a10_cfg = { 184 .size = 0x10, 185 }; 186 187 static const struct sunxi_sid_cfg sun7i_a20_cfg = { 188 .size = 0x200, 189 }; 190 191 static const struct sunxi_sid_cfg sun8i_h3_cfg = { 192 .value_offset = 0x200, 193 .size = 0x100, 194 .need_register_readout = true, 195 }; 196 197 static const struct sunxi_sid_cfg sun50i_a64_cfg = { 198 .value_offset = 0x200, 199 .size = 0x100, 200 }; 201 202 static const struct sunxi_sid_cfg sun50i_h6_cfg = { 203 .value_offset = 0x200, 204 .size = 0x200, 205 }; 206 207 static const struct of_device_id sunxi_sid_of_match[] = { 208 { .compatible = "allwinner,sun4i-a10-sid", .data = &sun4i_a10_cfg }, 209 { .compatible = "allwinner,sun7i-a20-sid", .data = &sun7i_a20_cfg }, 210 { .compatible = "allwinner,sun8i-a83t-sid", .data = &sun50i_a64_cfg }, 211 { .compatible = "allwinner,sun8i-h3-sid", .data = &sun8i_h3_cfg }, 212 { .compatible = "allwinner,sun20i-d1-sid", .data = &sun50i_a64_cfg }, 213 { .compatible = "allwinner,sun50i-a64-sid", .data = &sun50i_a64_cfg }, 214 { .compatible = "allwinner,sun50i-h5-sid", .data = &sun50i_a64_cfg }, 215 { .compatible = "allwinner,sun50i-h6-sid", .data = &sun50i_h6_cfg }, 216 {/* sentinel */}, 217 }; 218 MODULE_DEVICE_TABLE(of, sunxi_sid_of_match); 219 220 static struct platform_driver sunxi_sid_driver = { 221 .probe = sunxi_sid_probe, 222 .driver = { 223 .name = "eeprom-sunxi-sid", 224 .of_match_table = sunxi_sid_of_match, 225 }, 226 }; 227 module_platform_driver(sunxi_sid_driver); 228 229 MODULE_AUTHOR("Oliver Schinagl <oliver@schinagl.nl>"); 230 MODULE_DESCRIPTION("Allwinner sunxi security id driver"); 231 MODULE_LICENSE("GPL"); 232