drivers/nvmem/sunplus-ocotp.c

   1 // SPDX-License-Identifier: GPL-2.0
   2
   3 /*
   4  * The OCOTP driver for Sunplus SP7021
   5  *
   6  * Copyright (C) 2019 Sunplus Technology Inc., All rights reserved.
   7  */
   8
   9 #include <linux/bitfield.h>
  10 #include <linux/clk.h>
  11 #include <linux/delay.h>
  12 #include <linux/device.h>
  13 #include <linux/io.h>
  14 #include <linux/iopoll.h>
  15 #include <linux/module.h>
  16 #include <linux/mod_devicetable.h>
  17 #include <linux/nvmem-provider.h>
  18 #include <linux/platform_device.h>
  19
  20 /*
  21  * OTP memory
  22  * Each bank contains 4 words (32 bits).
  23  * Bank 0 starts at offset 0 from the base.
  24  */
  25
  26 #define OTP_WORDS_PER_BANK              4
  27 #define OTP_WORD_SIZE                   sizeof(u32)
  28 #define OTP_BIT_ADDR_OF_BANK            (8 * OTP_WORD_SIZE * OTP_WORDS_PER_BANK)
  29 #define QAC628_OTP_NUM_BANKS            8
  30 #define QAC628_OTP_SIZE                 (QAC628_OTP_NUM_BANKS * OTP_WORDS_PER_BANK * OTP_WORD_SIZE)
  31 #define OTP_READ_TIMEOUT_US             200000
  32
  33 /* HB_GPIO */
  34 #define ADDRESS_8_DATA                  0x20
  35
  36 /* OTP_RX */
  37 #define OTP_CONTROL_2                   0x48
  38 #define OTP_RD_PERIOD                   GENMASK(15, 8)
  39 #define OTP_RD_PERIOD_MASK              ~GENMASK(15, 8)
  40 #define CPU_CLOCK                       FIELD_PREP(OTP_RD_PERIOD, 30)
  41 #define SEL_BAK_KEY2                    BIT(5)
  42 #define SEL_BAK_KEY2_MASK               ~BIT(5)
  43 #define SW_TRIM_EN                      BIT(4)
  44 #define SW_TRIM_EN_MASK                 ~BIT(4)
  45 #define SEL_BAK_KEY                     BIT(3)
  46 #define SEL_BAK_KEY_MASK                ~BIT(3)
  47 #define OTP_READ                        BIT(2)
  48 #define OTP_LOAD_SECURE_DATA            BIT(1)
  49 #define OTP_LOAD_SECURE_DATA_MASK       ~BIT(1)
  50 #define OTP_DO_CRC                      BIT(0)
  51 #define OTP_DO_CRC_MASK                 ~BIT(0)
  52 #define OTP_STATUS                      0x4c
  53 #define OTP_READ_DONE                   BIT(4)
  54 #define OTP_READ_DONE_MASK              ~BIT(4)
  55 #define OTP_LOAD_SECURE_DONE_MASK       ~BIT(2)
  56 #define OTP_READ_ADDRESS                0x50
  57
  58 enum base_type {
  59         HB_GPIO,
  60         OTPRX,
  61         BASEMAX,
  62 };
  63
  64 struct sp_ocotp_priv {
  65         struct device *dev;
  66         void __iomem *base[BASEMAX];
  67         struct clk *clk;
  68 };
  69
  70 struct sp_ocotp_data {
  71         int size;
  72 };
  73
  74 static const struct sp_ocotp_data sp_otp_v0 = {
  75         .size = QAC628_OTP_SIZE,
  76 };
  77
  78 static int sp_otp_read_real(struct sp_ocotp_priv *otp, int addr, char *value)
  79 {
  80         unsigned int addr_data;
  81         unsigned int byte_shift;
  82         unsigned int status;
  83         int ret;
  84
  85         addr_data = addr % (OTP_WORD_SIZE * OTP_WORDS_PER_BANK);
  86         addr_data = addr_data / OTP_WORD_SIZE;
  87
  88         byte_shift = addr % (OTP_WORD_SIZE * OTP_WORDS_PER_BANK);
  89         byte_shift = byte_shift % OTP_WORD_SIZE;
  90
  91         addr = addr / (OTP_WORD_SIZE * OTP_WORDS_PER_BANK);
  92         addr = addr * OTP_BIT_ADDR_OF_BANK;
  93
  94         writel(readl(otp->base[OTPRX] + OTP_STATUS) & OTP_READ_DONE_MASK &
  95                OTP_LOAD_SECURE_DONE_MASK, otp->base[OTPRX] + OTP_STATUS);
  96         writel(addr, otp->base[OTPRX] + OTP_READ_ADDRESS);
  97         writel(readl(otp->base[OTPRX] + OTP_CONTROL_2) | OTP_READ,
  98                otp->base[OTPRX] + OTP_CONTROL_2);
  99         writel(readl(otp->base[OTPRX] + OTP_CONTROL_2) & SEL_BAK_KEY2_MASK & SW_TRIM_EN_MASK
 100                & SEL_BAK_KEY_MASK & OTP_LOAD_SECURE_DATA_MASK & OTP_DO_CRC_MASK,
 101                otp->base[OTPRX] + OTP_CONTROL_2);
 102         writel((readl(otp->base[OTPRX] + OTP_CONTROL_2) & OTP_RD_PERIOD_MASK) | CPU_CLOCK,
 103                otp->base[OTPRX] + OTP_CONTROL_2);
 104
 105         ret = readl_poll_timeout(otp->base[OTPRX] + OTP_STATUS, status,
 106                                  status & OTP_READ_DONE, 10, OTP_READ_TIMEOUT_US);
 107
 108         if (ret < 0)
 109                 return ret;
 110
 111         *value = (readl(otp->base[HB_GPIO] + ADDRESS_8_DATA + addr_data * OTP_WORD_SIZE)
 112                   >> (8 * byte_shift)) & 0xff;
 113
 114         return ret;
 115 }
 116
 117 static int sp_ocotp_read(void *priv, unsigned int offset, void *value, size_t bytes)
 118 {
 119         struct sp_ocotp_priv *otp = priv;
 120         unsigned int addr;
 121         char *buf = value;
 122         char val[4];
 123         int ret;
 124
 125         ret = clk_enable(otp->clk);
 126         if (ret)
 127                 return ret;
 128
 129         *buf = 0;
 130         for (addr = offset; addr < (offset + bytes); addr++) {
 131                 ret = sp_otp_read_real(otp, addr, val);
 132                 if (ret < 0) {
 133                         dev_err(otp->dev, "OTP read fail:%d at %d", ret, addr);
 134                         goto disable_clk;
 135                 }
 136
 137                 *buf++ = *val;
 138         }
 139
 140 disable_clk:
 141         clk_disable(otp->clk);
 142
 143         return ret;
 144 }
 145
 146 static struct nvmem_config sp_ocotp_nvmem_config = {
 147         .name = "sp-ocotp",
 148         .add_legacy_fixed_of_cells = true,
 149         .read_only = true,
 150         .word_size = 1,
 151         .size = QAC628_OTP_SIZE,
 152         .stride = 1,
 153         .reg_read = sp_ocotp_read,
 154         .owner = THIS_MODULE,
 155 };
 156
 157 static int sp_ocotp_probe(struct platform_device *pdev)
 158 {
 159         struct device *dev = &pdev->dev;
 160         struct nvmem_device *nvmem;
 161         struct sp_ocotp_priv *otp;
 162         struct resource *res;
 163         int ret;
 164
 165         otp = devm_kzalloc(dev, sizeof(*otp), GFP_KERNEL);
 166         if (!otp)
 167                 return -ENOMEM;
 168
 169         otp->dev = dev;
 170
 171         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "hb_gpio");
 172         otp->base[HB_GPIO] = devm_ioremap_resource(dev, res);
 173         if (IS_ERR(otp->base[HB_GPIO]))
 174                 return PTR_ERR(otp->base[HB_GPIO]);
 175
 176         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "otprx");
 177         otp->base[OTPRX] = devm_ioremap_resource(dev, res);
 178         if (IS_ERR(otp->base[OTPRX]))
 179                 return PTR_ERR(otp->base[OTPRX]);
 180
 181         otp->clk = devm_clk_get(&pdev->dev, NULL);
 182         if (IS_ERR(otp->clk))
 183                 return dev_err_probe(&pdev->dev, PTR_ERR(otp->clk),
 184                                                 "devm_clk_get fail\n");
 185
 186         ret = clk_prepare(otp->clk);
 187         if (ret < 0) {
 188                 dev_err(dev, "failed to prepare clk: %d\n", ret);
 189                 return ret;
 190         }
 191
 192         sp_ocotp_nvmem_config.priv = otp;
 193         sp_ocotp_nvmem_config.dev = dev;
 194
 195         nvmem = devm_nvmem_register(dev, &sp_ocotp_nvmem_config);
 196         if (IS_ERR(nvmem)) {
 197                 ret = dev_err_probe(&pdev->dev, PTR_ERR(nvmem),
 198                                                 "register nvmem device fail\n");
 199                 goto err;
 200         }
 201
 202         platform_set_drvdata(pdev, nvmem);
 203
 204         dev_dbg(dev, "banks:%d x wpb:%d x wsize:%d = %d",
 205                 (int)QAC628_OTP_NUM_BANKS, (int)OTP_WORDS_PER_BANK,
 206                 (int)OTP_WORD_SIZE, (int)QAC628_OTP_SIZE);
 207
 208         return 0;
 209 err:
 210         clk_unprepare(otp->clk);
 211         return ret;
 212 }
 213
 214 static const struct of_device_id sp_ocotp_dt_ids[] = {
 215         { .compatible = "sunplus,sp7021-ocotp", .data = &sp_otp_v0 },
 216         { }
 217 };
 218 MODULE_DEVICE_TABLE(of, sp_ocotp_dt_ids);
 219
 220 static struct platform_driver sp_otp_driver = {
 221         .probe     = sp_ocotp_probe,
 222         .driver    = {
 223                 .name           = "sunplus,sp7021-ocotp",
 224                 .of_match_table = sp_ocotp_dt_ids,
 225         }
 226 };
 227 module_platform_driver(sp_otp_driver);
 228
 229 MODULE_AUTHOR("Vincent Shih <vincent.sunplus@gmail.com>");
 230 MODULE_DESCRIPTION("Sunplus On-Chip OTP driver");
 231 MODULE_LICENSE("GPL");
 232