drivers/nvmem/qfprom.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2015 Srinivas Kandagatla <srinivas.kandagatla@linaro.org>
   4  */
   5
   6 #include <linux/clk.h>
   7 #include <linux/device.h>
   8 #include <linux/io.h>
   9 #include <linux/iopoll.h>
  10 #include <linux/kernel.h>
  11 #include <linux/module.h>
  12 #include <linux/mod_devicetable.h>
  13 #include <linux/nvmem-provider.h>
  14 #include <linux/platform_device.h>
  15 #include <linux/pm_domain.h>
  16 #include <linux/pm_runtime.h>
  17 #include <linux/property.h>
  18 #include <linux/regulator/consumer.h>
  19
  20 /* Blow timer clock frequency in Mhz */
  21 #define QFPROM_BLOW_TIMER_OFFSET 0x03c
  22
  23 /* Amount of time required to hold charge to blow fuse in micro-seconds */
  24 #define QFPROM_FUSE_BLOW_POLL_US        100
  25 #define QFPROM_FUSE_BLOW_TIMEOUT_US     1000
  26
  27 #define QFPROM_BLOW_STATUS_OFFSET       0x048
  28 #define QFPROM_BLOW_STATUS_BUSY         0x1
  29 #define QFPROM_BLOW_STATUS_READY        0x0
  30
  31 #define QFPROM_ACCEL_OFFSET             0x044
  32
  33 #define QFPROM_VERSION_OFFSET           0x0
  34 #define QFPROM_MAJOR_VERSION_SHIFT      28
  35 #define QFPROM_MAJOR_VERSION_MASK       GENMASK(31, QFPROM_MAJOR_VERSION_SHIFT)
  36 #define QFPROM_MINOR_VERSION_SHIFT      16
  37 #define QFPROM_MINOR_VERSION_MASK       GENMASK(27, QFPROM_MINOR_VERSION_SHIFT)
  38
  39 static bool read_raw_data;
  40 module_param(read_raw_data, bool, 0644);
  41 MODULE_PARM_DESC(read_raw_data, "Read raw instead of corrected data");
  42
  43 /**
  44  * struct qfprom_soc_data - config that varies from SoC to SoC.
  45  *
  46  * @accel_value:             Should contain qfprom accel value.
  47  * @qfprom_blow_timer_value: The timer value of qfprom when doing efuse blow.
  48  * @qfprom_blow_set_freq:    The frequency required to set when we start the
  49  *                           fuse blowing.
  50  * @qfprom_blow_uV:          LDO voltage to be set when doing efuse blow
  51  */
  52 struct qfprom_soc_data {
  53         u32 accel_value;
  54         u32 qfprom_blow_timer_value;
  55         u32 qfprom_blow_set_freq;
  56         int qfprom_blow_uV;
  57 };
  58
  59 /**
  60  * struct qfprom_priv - structure holding qfprom attributes
  61  *
  62  * @qfpraw:       iomapped memory space for qfprom-efuse raw address space.
  63  * @qfpconf:      iomapped memory space for qfprom-efuse configuration address
  64  *                space.
  65  * @qfpcorrected: iomapped memory space for qfprom corrected address space.
  66  * @qfpsecurity:  iomapped memory space for qfprom security control space.
  67  * @dev:          qfprom device structure.
  68  * @secclk:       Clock supply.
  69  * @vcc:          Regulator supply.
  70  * @soc_data:     Data that for things that varies from SoC to SoC.
  71  */
  72 struct qfprom_priv {
  73         void __iomem *qfpraw;
  74         void __iomem *qfpconf;
  75         void __iomem *qfpcorrected;
  76         void __iomem *qfpsecurity;
  77         struct device *dev;
  78         struct clk *secclk;
  79         struct regulator *vcc;
  80         const struct qfprom_soc_data *soc_data;
  81 };
  82
  83 /**
  84  * struct qfprom_touched_values - saved values to restore after blowing
  85  *
  86  * @clk_rate: The rate the clock was at before blowing.
  87  * @accel_val: The value of the accel reg before blowing.
  88  * @timer_val: The value of the timer before blowing.
  89  */
  90 struct qfprom_touched_values {
  91         unsigned long clk_rate;
  92         u32 accel_val;
  93         u32 timer_val;
  94 };
  95
  96 /**
  97  * struct qfprom_soc_compatible_data - Data matched against the SoC
  98  * compatible string.
  99  *
 100  * @keepout: Array of keepout regions for this SoC.
 101  * @nkeepout: Number of elements in the keepout array.
 102  */
 103 struct qfprom_soc_compatible_data {
 104         const struct nvmem_keepout *keepout;
 105         unsigned int nkeepout;
 106 };
 107
 108 static const struct nvmem_keepout sc7180_qfprom_keepout[] = {
 109         {.start = 0x128, .end = 0x148},
 110         {.start = 0x220, .end = 0x228}
 111 };
 112
 113 static const struct qfprom_soc_compatible_data sc7180_qfprom = {
 114         .keepout = sc7180_qfprom_keepout,
 115         .nkeepout = ARRAY_SIZE(sc7180_qfprom_keepout)
 116 };
 117
 118 static const struct nvmem_keepout sc7280_qfprom_keepout[] = {
 119         {.start = 0x128, .end = 0x148},
 120         {.start = 0x238, .end = 0x248}
 121 };
 122
 123 static const struct qfprom_soc_compatible_data sc7280_qfprom = {
 124         .keepout = sc7280_qfprom_keepout,
 125         .nkeepout = ARRAY_SIZE(sc7280_qfprom_keepout)
 126 };
 127
 128 /**
 129  * qfprom_disable_fuse_blowing() - Undo enabling of fuse blowing.
 130  * @priv: Our driver data.
 131  * @old:  The data that was stashed from before fuse blowing.
 132  *
 133  * Resets the value of the blow timer, accel register and the clock
 134  * and voltage settings.
 135  *
 136  * Prints messages if there are errors but doesn't return an error code
 137  * since there's not much we can do upon failure.
 138  */
 139 static void qfprom_disable_fuse_blowing(const struct qfprom_priv *priv,
 140                                         const struct qfprom_touched_values *old)
 141 {
 142         int ret;
 143
 144         writel(old->timer_val, priv->qfpconf + QFPROM_BLOW_TIMER_OFFSET);
 145         writel(old->accel_val, priv->qfpconf + QFPROM_ACCEL_OFFSET);
 146
 147         dev_pm_genpd_set_performance_state(priv->dev, 0);
 148         pm_runtime_put(priv->dev);
 149
 150         /*
 151          * This may be a shared rail and may be able to run at a lower rate
 152          * when we're not blowing fuses.  At the moment, the regulator framework
 153          * applies voltage constraints even on disabled rails, so remove our
 154          * constraints and allow the rail to be adjusted by other users.
 155          */
 156         ret = regulator_set_voltage(priv->vcc, 0, INT_MAX);
 157         if (ret)
 158                 dev_warn(priv->dev, "Failed to set 0 voltage (ignoring)\n");
 159
 160         ret = regulator_disable(priv->vcc);
 161         if (ret)
 162                 dev_warn(priv->dev, "Failed to disable regulator (ignoring)\n");
 163
 164         ret = clk_set_rate(priv->secclk, old->clk_rate);
 165         if (ret)
 166                 dev_warn(priv->dev,
 167                          "Failed to set clock rate for disable (ignoring)\n");
 168
 169         clk_disable_unprepare(priv->secclk);
 170 }
 171
 172 /**
 173  * qfprom_enable_fuse_blowing() - Enable fuse blowing.
 174  * @priv: Our driver data.
 175  * @old:  We'll stash stuff here to use when disabling.
 176  *
 177  * Sets the value of the blow timer, accel register and the clock
 178  * and voltage settings.
 179  *
 180  * Prints messages if there are errors so caller doesn't need to.
 181  *
 182  * Return: 0 or -err.
 183  */
 184 static int qfprom_enable_fuse_blowing(const struct qfprom_priv *priv,
 185                                       struct qfprom_touched_values *old)
 186 {
 187         int ret;
 188         int qfprom_blow_uV = priv->soc_data->qfprom_blow_uV;
 189
 190         ret = clk_prepare_enable(priv->secclk);
 191         if (ret) {
 192                 dev_err(priv->dev, "Failed to enable clock\n");
 193                 return ret;
 194         }
 195
 196         old->clk_rate = clk_get_rate(priv->secclk);
 197         ret = clk_set_rate(priv->secclk, priv->soc_data->qfprom_blow_set_freq);
 198         if (ret) {
 199                 dev_err(priv->dev, "Failed to set clock rate for enable\n");
 200                 goto err_clk_prepared;
 201         }
 202
 203         /*
 204          * Hardware requires a minimum voltage for fuse blowing.
 205          * This may be a shared rail so don't specify a maximum.
 206          * Regulator constraints will cap to the actual maximum.
 207          */
 208         ret = regulator_set_voltage(priv->vcc, qfprom_blow_uV, INT_MAX);
 209         if (ret) {
 210                 dev_err(priv->dev, "Failed to set %duV\n", qfprom_blow_uV);
 211                 goto err_clk_rate_set;
 212         }
 213
 214         ret = regulator_enable(priv->vcc);
 215         if (ret) {
 216                 dev_err(priv->dev, "Failed to enable regulator\n");
 217                 goto err_clk_rate_set;
 218         }
 219
 220         ret = pm_runtime_get_sync(priv->dev);
 221         if (ret < 0) {
 222                 pm_runtime_put_noidle(priv->dev);
 223                 dev_err(priv->dev, "Failed to enable power-domain\n");
 224                 goto err_reg_enable;
 225         }
 226         dev_pm_genpd_set_performance_state(priv->dev, INT_MAX);
 227
 228         old->timer_val = readl(priv->qfpconf + QFPROM_BLOW_TIMER_OFFSET);
 229         old->accel_val = readl(priv->qfpconf + QFPROM_ACCEL_OFFSET);
 230         writel(priv->soc_data->qfprom_blow_timer_value,
 231                priv->qfpconf + QFPROM_BLOW_TIMER_OFFSET);
 232         writel(priv->soc_data->accel_value,
 233                priv->qfpconf + QFPROM_ACCEL_OFFSET);
 234
 235         return 0;
 236
 237 err_reg_enable:
 238         regulator_disable(priv->vcc);
 239 err_clk_rate_set:
 240         clk_set_rate(priv->secclk, old->clk_rate);
 241 err_clk_prepared:
 242         clk_disable_unprepare(priv->secclk);
 243         return ret;
 244 }
 245
 246 /**
 247  * qfprom_efuse_reg_write() - Write to fuses.
 248  * @context: Our driver data.
 249  * @reg:     The offset to write at.
 250  * @_val:    Pointer to data to write.
 251  * @bytes:   The number of bytes to write.
 252  *
 253  * Writes to fuses.  WARNING: THIS IS PERMANENT.
 254  *
 255  * Return: 0 or -err.
 256  */
 257 static int qfprom_reg_write(void *context, unsigned int reg, void *_val,
 258                             size_t bytes)
 259 {
 260         struct qfprom_priv *priv = context;
 261         struct qfprom_touched_values old;
 262         int words = bytes / 4;
 263         u32 *value = _val;
 264         u32 blow_status;
 265         int ret;
 266         int i;
 267
 268         dev_dbg(priv->dev,
 269                 "Writing to raw qfprom region : %#010x of size: %zu\n",
 270                 reg, bytes);
 271
 272         /*
 273          * The hardware only allows us to write word at a time, but we can
 274          * read byte at a time.  Until the nvmem framework allows a separate
 275          * word_size and stride for reading vs. writing, we'll enforce here.
 276          */
 277         if (bytes % 4) {
 278                 dev_err(priv->dev,
 279                         "%zu is not an integral number of words\n", bytes);
 280                 return -EINVAL;
 281         }
 282         if (reg % 4) {
 283                 dev_err(priv->dev,
 284                         "Invalid offset: %#x.  Must be word aligned\n", reg);
 285                 return -EINVAL;
 286         }
 287
 288         ret = qfprom_enable_fuse_blowing(priv, &old);
 289         if (ret)
 290                 return ret;
 291
 292         ret = readl_relaxed_poll_timeout(
 293                 priv->qfpconf + QFPROM_BLOW_STATUS_OFFSET,
 294                 blow_status, blow_status == QFPROM_BLOW_STATUS_READY,
 295                 QFPROM_FUSE_BLOW_POLL_US, QFPROM_FUSE_BLOW_TIMEOUT_US);
 296
 297         if (ret) {
 298                 dev_err(priv->dev,
 299                         "Timeout waiting for initial ready; aborting.\n");
 300                 goto exit_enabled_fuse_blowing;
 301         }
 302
 303         for (i = 0; i < words; i++)
 304                 writel(value[i], priv->qfpraw + reg + (i * 4));
 305
 306         ret = readl_relaxed_poll_timeout(
 307                 priv->qfpconf + QFPROM_BLOW_STATUS_OFFSET,
 308                 blow_status, blow_status == QFPROM_BLOW_STATUS_READY,
 309                 QFPROM_FUSE_BLOW_POLL_US, QFPROM_FUSE_BLOW_TIMEOUT_US);
 310
 311         /* Give an error, but not much we can do in this case */
 312         if (ret)
 313                 dev_err(priv->dev, "Timeout waiting for finish.\n");
 314
 315 exit_enabled_fuse_blowing:
 316         qfprom_disable_fuse_blowing(priv, &old);
 317
 318         return ret;
 319 }
 320
 321 static int qfprom_reg_read(void *context,
 322                         unsigned int reg, void *_val, size_t bytes)
 323 {
 324         struct qfprom_priv *priv = context;
 325         u8 *val = _val;
 326         int i = 0, words = bytes;
 327         void __iomem *base = priv->qfpcorrected;
 328
 329         if (read_raw_data && priv->qfpraw)
 330                 base = priv->qfpraw;
 331
 332         while (words--)
 333                 *val++ = readb(base + reg + i++);
 334
 335         return 0;
 336 }
 337
 338 static void qfprom_runtime_disable(void *data)
 339 {
 340         pm_runtime_disable(data);
 341 }
 342
 343 static const struct qfprom_soc_data qfprom_7_8_data = {
 344         .accel_value = 0xD10,
 345         .qfprom_blow_timer_value = 25,
 346         .qfprom_blow_set_freq = 4800000,
 347         .qfprom_blow_uV = 1800000,
 348 };
 349
 350 static const struct qfprom_soc_data qfprom_7_15_data = {
 351         .accel_value = 0xD08,
 352         .qfprom_blow_timer_value = 24,
 353         .qfprom_blow_set_freq = 4800000,
 354         .qfprom_blow_uV = 1900000,
 355 };
 356
 357 static int qfprom_probe(struct platform_device *pdev)
 358 {
 359         struct nvmem_config econfig = {
 360                 .name = "qfprom",
 361                 .stride = 1,
 362                 .word_size = 1,
 363                 .id = NVMEM_DEVID_AUTO,
 364                 .reg_read = qfprom_reg_read,
 365         };
 366         struct device *dev = &pdev->dev;
 367         struct resource *res;
 368         struct nvmem_device *nvmem;
 369         const struct qfprom_soc_compatible_data *soc_data;
 370         struct qfprom_priv *priv;
 371         int ret;
 372
 373         priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
 374         if (!priv)
 375                 return -ENOMEM;
 376
 377         /* The corrected section is always provided */
 378         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 379         priv->qfpcorrected = devm_ioremap_resource(dev, res);
 380         if (IS_ERR(priv->qfpcorrected))
 381                 return PTR_ERR(priv->qfpcorrected);
 382
 383         econfig.size = resource_size(res);
 384         econfig.dev = dev;
 385         econfig.priv = priv;
 386
 387         priv->dev = dev;
 388         soc_data = device_get_match_data(dev);
 389         if (soc_data) {
 390                 econfig.keepout = soc_data->keepout;
 391                 econfig.nkeepout = soc_data->nkeepout;
 392         }
 393
 394         /*
 395          * If more than one region is provided then the OS has the ability
 396          * to write.
 397          */
 398         res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
 399         if (res) {
 400                 u32 version;
 401                 int major_version, minor_version;
 402
 403                 priv->qfpraw = devm_ioremap_resource(dev, res);
 404                 if (IS_ERR(priv->qfpraw))
 405                         return PTR_ERR(priv->qfpraw);
 406                 res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
 407                 priv->qfpconf = devm_ioremap_resource(dev, res);
 408                 if (IS_ERR(priv->qfpconf))
 409                         return PTR_ERR(priv->qfpconf);
 410                 res = platform_get_resource(pdev, IORESOURCE_MEM, 3);
 411                 priv->qfpsecurity = devm_ioremap_resource(dev, res);
 412                 if (IS_ERR(priv->qfpsecurity))
 413                         return PTR_ERR(priv->qfpsecurity);
 414
 415                 version = readl(priv->qfpsecurity + QFPROM_VERSION_OFFSET);
 416                 major_version = (version & QFPROM_MAJOR_VERSION_MASK) >>
 417                                 QFPROM_MAJOR_VERSION_SHIFT;
 418                 minor_version = (version & QFPROM_MINOR_VERSION_MASK) >>
 419                                 QFPROM_MINOR_VERSION_SHIFT;
 420
 421                 if (major_version == 7 && minor_version == 8)
 422                         priv->soc_data = &qfprom_7_8_data;
 423                 else if (major_version == 7 && minor_version == 15)
 424                         priv->soc_data = &qfprom_7_15_data;
 425
 426                 priv->vcc = devm_regulator_get(&pdev->dev, "vcc");
 427                 if (IS_ERR(priv->vcc))
 428                         return PTR_ERR(priv->vcc);
 429
 430                 priv->secclk = devm_clk_get(dev, "core");
 431                 if (IS_ERR(priv->secclk)) {
 432                         ret = PTR_ERR(priv->secclk);
 433                         if (ret != -EPROBE_DEFER)
 434                                 dev_err(dev, "Error getting clock: %d\n", ret);
 435                         return ret;
 436                 }
 437
 438                 /* Only enable writing if we have SoC data. */
 439                 if (priv->soc_data)
 440                         econfig.reg_write = qfprom_reg_write;
 441         }
 442
 443         pm_runtime_enable(dev);
 444         ret = devm_add_action_or_reset(dev, qfprom_runtime_disable, dev);
 445         if (ret)
 446                 return ret;
 447
 448         nvmem = devm_nvmem_register(dev, &econfig);
 449
 450         return PTR_ERR_OR_ZERO(nvmem);
 451 }
 452
 453 static const struct of_device_id qfprom_of_match[] = {
 454         { .compatible = "qcom,qfprom",},
 455         { .compatible = "qcom,sc7180-qfprom", .data = &sc7180_qfprom},
 456         { .compatible = "qcom,sc7280-qfprom", .data = &sc7280_qfprom},
 457         {/* sentinel */},
 458 };
 459 MODULE_DEVICE_TABLE(of, qfprom_of_match);
 460
 461 static struct platform_driver qfprom_driver = {
 462         .probe = qfprom_probe,
 463         .driver = {
 464                 .name = "qcom,qfprom",
 465                 .of_match_table = qfprom_of_match,
 466         },
 467 };
 468 module_platform_driver(qfprom_driver);
 469 MODULE_AUTHOR("Srinivas Kandagatla <srinivas.kandagatla@linaro.org>");
 470 MODULE_DESCRIPTION("Qualcomm QFPROM driver");
 471 MODULE_LICENSE("GPL v2");