1 // SPDX-License-Identifier: GPL-2.0 2 // Copyright (C) 2019 Spreadtrum Communications Inc. 3 4 #include <linux/clk.h> 5 #include <linux/delay.h> 6 #include <linux/hwspinlock.h> 7 #include <linux/io.h> 8 #include <linux/module.h> 9 #include <linux/nvmem-provider.h> 10 #include <linux/of_device.h> 11 #include <linux/platform_device.h> 12 13 #define SPRD_EFUSE_ENABLE 0x20 14 #define SPRD_EFUSE_ERR_FLAG 0x24 15 #define SPRD_EFUSE_ERR_CLR 0x28 16 #define SPRD_EFUSE_MAGIC_NUM 0x2c 17 #define SPRD_EFUSE_FW_CFG 0x50 18 #define SPRD_EFUSE_PW_SWT 0x54 19 #define SPRD_EFUSE_MEM(val) (0x1000 + ((val) << 2)) 20 21 #define SPRD_EFUSE_VDD_EN BIT(0) 22 #define SPRD_EFUSE_AUTO_CHECK_EN BIT(1) 23 #define SPRD_EFUSE_DOUBLE_EN BIT(2) 24 #define SPRD_EFUSE_MARGIN_RD_EN BIT(3) 25 #define SPRD_EFUSE_LOCK_WR_EN BIT(4) 26 27 #define SPRD_EFUSE_ERR_CLR_MASK GENMASK(13, 0) 28 29 #define SPRD_EFUSE_ENK1_ON BIT(0) 30 #define SPRD_EFUSE_ENK2_ON BIT(1) 31 #define SPRD_EFUSE_PROG_EN BIT(2) 32 33 #define SPRD_EFUSE_MAGIC_NUMBER 0x8810 34 35 /* Block width (bytes) definitions */ 36 #define SPRD_EFUSE_BLOCK_WIDTH 4 37 38 /* 39 * The Spreadtrum AP efuse contains 2 parts: normal efuse and secure efuse, 40 * and we can only access the normal efuse in kernel. So define the normal 41 * block offset index and normal block numbers. 42 */ 43 #define SPRD_EFUSE_NORMAL_BLOCK_NUMS 24 44 #define SPRD_EFUSE_NORMAL_BLOCK_OFFSET 72 45 46 /* Timeout (ms) for the trylock of hardware spinlocks */ 47 #define SPRD_EFUSE_HWLOCK_TIMEOUT 5000 48 49 /* 50 * Since different Spreadtrum SoC chip can have different normal block numbers 51 * and offset. And some SoC can support block double feature, which means 52 * when reading or writing data to efuse memory, the controller can save double 53 * data in case one data become incorrect after a long period. 54 * 55 * Thus we should save them in the device data structure. 56 */ 57 struct sprd_efuse_variant_data { 58 u32 blk_nums; 59 u32 blk_offset; 60 bool blk_double; 61 }; 62 63 struct sprd_efuse { 64 struct device *dev; 65 struct clk *clk; 66 struct hwspinlock *hwlock; 67 struct mutex mutex; 68 void __iomem *base; 69 const struct sprd_efuse_variant_data *data; 70 }; 71 72 static const struct sprd_efuse_variant_data ums312_data = { 73 .blk_nums = SPRD_EFUSE_NORMAL_BLOCK_NUMS, 74 .blk_offset = SPRD_EFUSE_NORMAL_BLOCK_OFFSET, 75 .blk_double = false, 76 }; 77 78 /* 79 * On Spreadtrum platform, we have multi-subsystems will access the unique 80 * efuse controller, so we need one hardware spinlock to synchronize between 81 * the multiple subsystems. 82 */ 83 static int sprd_efuse_lock(struct sprd_efuse *efuse) 84 { 85 int ret; 86 87 mutex_lock(&efuse->mutex); 88 89 ret = hwspin_lock_timeout_raw(efuse->hwlock, 90 SPRD_EFUSE_HWLOCK_TIMEOUT); 91 if (ret) { 92 dev_err(efuse->dev, "timeout get the hwspinlock\n"); 93 mutex_unlock(&efuse->mutex); 94 return ret; 95 } 96 97 return 0; 98 } 99 100 static void sprd_efuse_unlock(struct sprd_efuse *efuse) 101 { 102 hwspin_unlock_raw(efuse->hwlock); 103 mutex_unlock(&efuse->mutex); 104 } 105 106 static void sprd_efuse_set_prog_power(struct sprd_efuse *efuse, bool en) 107 { 108 u32 val = readl(efuse->base + SPRD_EFUSE_PW_SWT); 109 110 if (en) 111 val &= ~SPRD_EFUSE_ENK2_ON; 112 else 113 val &= ~SPRD_EFUSE_ENK1_ON; 114 115 writel(val, efuse->base + SPRD_EFUSE_PW_SWT); 116 117 /* Open or close efuse power need wait 1000us to make power stable. */ 118 usleep_range(1000, 1200); 119 120 if (en) 121 val |= SPRD_EFUSE_ENK1_ON; 122 else 123 val |= SPRD_EFUSE_ENK2_ON; 124 125 writel(val, efuse->base + SPRD_EFUSE_PW_SWT); 126 127 /* Open or close efuse power need wait 1000us to make power stable. */ 128 usleep_range(1000, 1200); 129 } 130 131 static void sprd_efuse_set_read_power(struct sprd_efuse *efuse, bool en) 132 { 133 u32 val = readl(efuse->base + SPRD_EFUSE_ENABLE); 134 135 if (en) 136 val |= SPRD_EFUSE_VDD_EN; 137 else 138 val &= ~SPRD_EFUSE_VDD_EN; 139 140 writel(val, efuse->base + SPRD_EFUSE_ENABLE); 141 142 /* Open or close efuse power need wait 1000us to make power stable. */ 143 usleep_range(1000, 1200); 144 } 145 146 static void sprd_efuse_set_prog_lock(struct sprd_efuse *efuse, bool en) 147 { 148 u32 val = readl(efuse->base + SPRD_EFUSE_ENABLE); 149 150 if (en) 151 val |= SPRD_EFUSE_LOCK_WR_EN; 152 else 153 val &= ~SPRD_EFUSE_LOCK_WR_EN; 154 155 writel(val, efuse->base + SPRD_EFUSE_ENABLE); 156 } 157 158 static void sprd_efuse_set_auto_check(struct sprd_efuse *efuse, bool en) 159 { 160 u32 val = readl(efuse->base + SPRD_EFUSE_ENABLE); 161 162 if (en) 163 val |= SPRD_EFUSE_AUTO_CHECK_EN; 164 else 165 val &= ~SPRD_EFUSE_AUTO_CHECK_EN; 166 167 writel(val, efuse->base + SPRD_EFUSE_ENABLE); 168 } 169 170 static void sprd_efuse_set_data_double(struct sprd_efuse *efuse, bool en) 171 { 172 u32 val = readl(efuse->base + SPRD_EFUSE_ENABLE); 173 174 if (en) 175 val |= SPRD_EFUSE_DOUBLE_EN; 176 else 177 val &= ~SPRD_EFUSE_DOUBLE_EN; 178 179 writel(val, efuse->base + SPRD_EFUSE_ENABLE); 180 } 181 182 static void sprd_efuse_set_prog_en(struct sprd_efuse *efuse, bool en) 183 { 184 u32 val = readl(efuse->base + SPRD_EFUSE_PW_SWT); 185 186 if (en) 187 val |= SPRD_EFUSE_PROG_EN; 188 else 189 val &= ~SPRD_EFUSE_PROG_EN; 190 191 writel(val, efuse->base + SPRD_EFUSE_PW_SWT); 192 } 193 194 static int sprd_efuse_raw_prog(struct sprd_efuse *efuse, u32 blk, bool doub, 195 bool lock, u32 *data) 196 { 197 u32 status; 198 int ret = 0; 199 200 /* 201 * We need set the correct magic number before writing the efuse to 202 * allow programming, and block other programming until we clear the 203 * magic number. 204 */ 205 writel(SPRD_EFUSE_MAGIC_NUMBER, 206 efuse->base + SPRD_EFUSE_MAGIC_NUM); 207 208 /* 209 * Power on the efuse, enable programme and enable double data 210 * if asked. 211 */ 212 sprd_efuse_set_prog_power(efuse, true); 213 sprd_efuse_set_prog_en(efuse, true); 214 sprd_efuse_set_data_double(efuse, doub); 215 216 /* 217 * Enable the auto-check function to validate if the programming is 218 * successful. 219 */ 220 sprd_efuse_set_auto_check(efuse, true); 221 222 writel(*data, efuse->base + SPRD_EFUSE_MEM(blk)); 223 224 /* Disable auto-check and data double after programming */ 225 sprd_efuse_set_auto_check(efuse, false); 226 sprd_efuse_set_data_double(efuse, false); 227 228 /* 229 * Check the efuse error status, if the programming is successful, 230 * we should lock this efuse block to avoid programming again. 231 */ 232 status = readl(efuse->base + SPRD_EFUSE_ERR_FLAG); 233 if (status) { 234 dev_err(efuse->dev, 235 "write error status %d of block %d\n", ret, blk); 236 237 writel(SPRD_EFUSE_ERR_CLR_MASK, 238 efuse->base + SPRD_EFUSE_ERR_CLR); 239 ret = -EBUSY; 240 } else { 241 sprd_efuse_set_prog_lock(efuse, lock); 242 writel(*data, efuse->base + SPRD_EFUSE_MEM(blk)); 243 sprd_efuse_set_prog_lock(efuse, false); 244 } 245 246 sprd_efuse_set_prog_power(efuse, false); 247 writel(0, efuse->base + SPRD_EFUSE_MAGIC_NUM); 248 249 return ret; 250 } 251 252 static int sprd_efuse_raw_read(struct sprd_efuse *efuse, int blk, u32 *val, 253 bool doub) 254 { 255 u32 status; 256 257 /* 258 * Need power on the efuse before reading data from efuse, and will 259 * power off the efuse after reading process. 260 */ 261 sprd_efuse_set_read_power(efuse, true); 262 263 /* Enable double data if asked */ 264 sprd_efuse_set_data_double(efuse, doub); 265 266 /* Start to read data from efuse block */ 267 *val = readl(efuse->base + SPRD_EFUSE_MEM(blk)); 268 269 /* Disable double data */ 270 sprd_efuse_set_data_double(efuse, false); 271 272 /* Power off the efuse */ 273 sprd_efuse_set_read_power(efuse, false); 274 275 /* 276 * Check the efuse error status and clear them if there are some 277 * errors occurred. 278 */ 279 status = readl(efuse->base + SPRD_EFUSE_ERR_FLAG); 280 if (status) { 281 dev_err(efuse->dev, 282 "read error status %d of block %d\n", status, blk); 283 284 writel(SPRD_EFUSE_ERR_CLR_MASK, 285 efuse->base + SPRD_EFUSE_ERR_CLR); 286 return -EBUSY; 287 } 288 289 return 0; 290 } 291 292 static int sprd_efuse_read(void *context, u32 offset, void *val, size_t bytes) 293 { 294 struct sprd_efuse *efuse = context; 295 bool blk_double = efuse->data->blk_double; 296 u32 index = offset / SPRD_EFUSE_BLOCK_WIDTH + efuse->data->blk_offset; 297 u32 blk_offset = (offset % SPRD_EFUSE_BLOCK_WIDTH) * BITS_PER_BYTE; 298 u32 data; 299 int ret; 300 301 ret = sprd_efuse_lock(efuse); 302 if (ret) 303 return ret; 304 305 ret = clk_prepare_enable(efuse->clk); 306 if (ret) 307 goto unlock; 308 309 ret = sprd_efuse_raw_read(efuse, index, &data, blk_double); 310 if (!ret) { 311 data >>= blk_offset; 312 memcpy(val, &data, bytes); 313 } 314 315 clk_disable_unprepare(efuse->clk); 316 317 unlock: 318 sprd_efuse_unlock(efuse); 319 return ret; 320 } 321 322 static int sprd_efuse_write(void *context, u32 offset, void *val, size_t bytes) 323 { 324 struct sprd_efuse *efuse = context; 325 int ret; 326 327 ret = sprd_efuse_lock(efuse); 328 if (ret) 329 return ret; 330 331 ret = clk_prepare_enable(efuse->clk); 332 if (ret) 333 goto unlock; 334 335 ret = sprd_efuse_raw_prog(efuse, offset, false, false, val); 336 337 clk_disable_unprepare(efuse->clk); 338 339 unlock: 340 sprd_efuse_unlock(efuse); 341 return ret; 342 } 343 344 static int sprd_efuse_probe(struct platform_device *pdev) 345 { 346 struct device_node *np = pdev->dev.of_node; 347 struct nvmem_device *nvmem; 348 struct nvmem_config econfig = { }; 349 struct sprd_efuse *efuse; 350 const struct sprd_efuse_variant_data *pdata; 351 int ret; 352 353 pdata = of_device_get_match_data(&pdev->dev); 354 if (!pdata) { 355 dev_err(&pdev->dev, "No matching driver data found\n"); 356 return -EINVAL; 357 } 358 359 efuse = devm_kzalloc(&pdev->dev, sizeof(*efuse), GFP_KERNEL); 360 if (!efuse) 361 return -ENOMEM; 362 363 efuse->base = devm_platform_ioremap_resource(pdev, 0); 364 if (!efuse->base) 365 return -ENOMEM; 366 367 ret = of_hwspin_lock_get_id(np, 0); 368 if (ret < 0) { 369 dev_err(&pdev->dev, "failed to get hwlock id\n"); 370 return ret; 371 } 372 373 efuse->hwlock = devm_hwspin_lock_request_specific(&pdev->dev, ret); 374 if (!efuse->hwlock) { 375 dev_err(&pdev->dev, "failed to request hwlock\n"); 376 return -ENXIO; 377 } 378 379 efuse->clk = devm_clk_get(&pdev->dev, "enable"); 380 if (IS_ERR(efuse->clk)) { 381 dev_err(&pdev->dev, "failed to get enable clock\n"); 382 return PTR_ERR(efuse->clk); 383 } 384 385 mutex_init(&efuse->mutex); 386 efuse->dev = &pdev->dev; 387 efuse->data = pdata; 388 389 econfig.stride = 1; 390 econfig.word_size = 1; 391 econfig.read_only = false; 392 econfig.name = "sprd-efuse"; 393 econfig.size = efuse->data->blk_nums * SPRD_EFUSE_BLOCK_WIDTH; 394 econfig.reg_read = sprd_efuse_read; 395 econfig.reg_write = sprd_efuse_write; 396 econfig.priv = efuse; 397 econfig.dev = &pdev->dev; 398 nvmem = devm_nvmem_register(&pdev->dev, &econfig); 399 if (IS_ERR(nvmem)) { 400 dev_err(&pdev->dev, "failed to register nvmem\n"); 401 return PTR_ERR(nvmem); 402 } 403 404 return 0; 405 } 406 407 static const struct of_device_id sprd_efuse_of_match[] = { 408 { .compatible = "sprd,ums312-efuse", .data = &ums312_data }, 409 { } 410 }; 411 412 static struct platform_driver sprd_efuse_driver = { 413 .probe = sprd_efuse_probe, 414 .driver = { 415 .name = "sprd-efuse", 416 .of_match_table = sprd_efuse_of_match, 417 }, 418 }; 419 420 module_platform_driver(sprd_efuse_driver); 421 422 MODULE_AUTHOR("Freeman Liu <freeman.liu@spreadtrum.com>"); 423 MODULE_DESCRIPTION("Spreadtrum AP efuse driver"); 424 MODULE_LICENSE("GPL v2"); 425