drivers/misc/mxs_ocotp.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Freescale i.MX28 OCOTP Driver
   4  *
   5  * Copyright (C) 2014 Marek Vasut <marex@denx.de>
   6  *
   7  * Note: The i.MX23/i.MX28 OCOTP block is a predecessor to the OCOTP block
   8  *       used in i.MX6 . While these blocks are very similar at the first
   9  *       glance, by digging deeper, one will notice differences (like the
  10  *       tight dependence on MXS power block, some completely new registers
  11  *       etc.) which would make common driver an ifdef nightmare :-(
  12  */
  13
  14 #include <common.h>
  15 #include <fuse.h>
  16 #include <linux/errno.h>
  17 #include <asm/io.h>
  18 #include <asm/arch/clock.h>
  19 #include <asm/arch/imx-regs.h>
  20 #include <asm/arch/sys_proto.h>
  21
  22 #define MXS_OCOTP_TIMEOUT       100000
  23
  24 static struct mxs_ocotp_regs *ocotp_regs =
  25         (struct mxs_ocotp_regs *)MXS_OCOTP_BASE;
  26 static struct mxs_power_regs *power_regs =
  27         (struct mxs_power_regs *)MXS_POWER_BASE;
  28 static struct mxs_clkctrl_regs *clkctrl_regs =
  29         (struct mxs_clkctrl_regs *)MXS_CLKCTRL_BASE;
  30
  31 static int mxs_ocotp_wait_busy_clear(void)
  32 {
  33         uint32_t reg;
  34         int timeout = MXS_OCOTP_TIMEOUT;
  35
  36         while (--timeout) {
  37                 reg = readl(&ocotp_regs->hw_ocotp_ctrl);
  38                 if (!(reg & OCOTP_CTRL_BUSY))
  39                         break;
  40                 udelay(10);
  41         }
  42
  43         if (!timeout)
  44                 return -EINVAL;
  45
  46         /* Wait a little as per FSL datasheet's 'write postamble' section. */
  47         udelay(10);
  48
  49         return 0;
  50 }
  51
  52 static void mxs_ocotp_clear_error(void)
  53 {
  54         writel(OCOTP_CTRL_ERROR, &ocotp_regs->hw_ocotp_ctrl_clr);
  55 }
  56
  57 static int mxs_ocotp_read_bank_open(bool open)
  58 {
  59         int ret = 0;
  60
  61         if (open) {
  62                 writel(OCOTP_CTRL_RD_BANK_OPEN,
  63                        &ocotp_regs->hw_ocotp_ctrl_set);
  64
  65                 /*
  66                  * Wait before polling the BUSY bit, since the BUSY bit might
  67                  * be asserted only after a few HCLK cycles and if we were to
  68                  * poll immediatelly, we could miss the busy bit.
  69                  */
  70                 udelay(10);
  71                 ret = mxs_ocotp_wait_busy_clear();
  72         } else {
  73                 writel(OCOTP_CTRL_RD_BANK_OPEN,
  74                        &ocotp_regs->hw_ocotp_ctrl_clr);
  75         }
  76
  77         return ret;
  78 }
  79
  80 static void mxs_ocotp_scale_vddio(bool enter, uint32_t *val)
  81 {
  82         uint32_t scale_val;
  83
  84         if (enter) {
  85                 /*
  86                  * Enter the fuse programming VDDIO voltage setup. We start
  87                  * scaling the voltage from it's current value down to 2.8V
  88                  * which is the one and only correct voltage for programming
  89                  * the OCOTP fuses (according to datasheet).
  90                  */
  91                 scale_val = readl(&power_regs->hw_power_vddioctrl);
  92                 scale_val &= POWER_VDDIOCTRL_TRG_MASK;
  93
  94                 /* Return the original voltage. */
  95                 *val = scale_val;
  96
  97                 /*
  98                  * Start scaling VDDIO down to 0x2, which is 2.8V . Actually,
  99                  * the value 0x0 should be 2.8V, but that's not the case on
 100                  * most designs due to load etc., so we play safe. Undervolt
 101                  * can actually cause incorrect programming of the fuses and
 102                  * or reboots of the board.
 103                  */
 104                 while (scale_val > 2) {
 105                         clrsetbits_le32(&power_regs->hw_power_vddioctrl,
 106                                         POWER_VDDIOCTRL_TRG_MASK, --scale_val);
 107                         udelay(500);
 108                 }
 109         } else {
 110                 /* Start scaling VDDIO up to original value . */
 111                 for (scale_val = 2; scale_val <= *val; scale_val++) {
 112                         clrsetbits_le32(&power_regs->hw_power_vddioctrl,
 113                                         POWER_VDDIOCTRL_TRG_MASK, scale_val);
 114                         udelay(500);
 115                 }
 116         }
 117
 118         mdelay(10);
 119 }
 120
 121 static int mxs_ocotp_wait_hclk_ready(void)
 122 {
 123         uint32_t reg, timeout = MXS_OCOTP_TIMEOUT;
 124
 125         while (--timeout) {
 126                 reg = readl(&clkctrl_regs->hw_clkctrl_hbus);
 127                 if (!(reg & CLKCTRL_HBUS_ASM_BUSY))
 128                         break;
 129         }
 130
 131         if (!timeout)
 132                 return -EINVAL;
 133
 134         return 0;
 135 }
 136
 137 static int mxs_ocotp_scale_hclk(bool enter, uint32_t *val)
 138 {
 139         uint32_t scale_val;
 140         int ret;
 141
 142         ret = mxs_ocotp_wait_hclk_ready();
 143         if (ret)
 144                 return ret;
 145
 146         /* Set CPU bypass */
 147         writel(CLKCTRL_CLKSEQ_BYPASS_CPU,
 148                &clkctrl_regs->hw_clkctrl_clkseq_set);
 149
 150         if (enter) {
 151                 /* Return the original HCLK clock speed. */
 152                 *val = readl(&clkctrl_regs->hw_clkctrl_hbus);
 153                 *val &= CLKCTRL_HBUS_DIV_MASK;
 154                 *val >>= CLKCTRL_HBUS_DIV_OFFSET;
 155
 156                 /* Scale the HCLK to 454/19 = 23.9 MHz . */
 157                 scale_val = (~19) << CLKCTRL_HBUS_DIV_OFFSET;
 158                 scale_val &= CLKCTRL_HBUS_DIV_MASK;
 159         } else {
 160                 /* Scale the HCLK back to original frequency. */
 161                 scale_val = (~(*val)) << CLKCTRL_HBUS_DIV_OFFSET;
 162                 scale_val &= CLKCTRL_HBUS_DIV_MASK;
 163         }
 164
 165         writel(CLKCTRL_HBUS_DIV_MASK,
 166                &clkctrl_regs->hw_clkctrl_hbus_set);
 167         writel(scale_val,
 168                &clkctrl_regs->hw_clkctrl_hbus_clr);
 169
 170         mdelay(10);
 171
 172         ret = mxs_ocotp_wait_hclk_ready();
 173         if (ret)
 174                 return ret;
 175
 176         /* Disable CPU bypass */
 177         writel(CLKCTRL_CLKSEQ_BYPASS_CPU,
 178                &clkctrl_regs->hw_clkctrl_clkseq_clr);
 179
 180         mdelay(10);
 181
 182         return 0;
 183 }
 184
 185 static int mxs_ocotp_write_fuse(uint32_t addr, uint32_t mask)
 186 {
 187         uint32_t hclk_val, vddio_val;
 188         int ret;
 189
 190         mxs_ocotp_clear_error();
 191
 192         /* Make sure the banks are closed for reading. */
 193         ret = mxs_ocotp_read_bank_open(0);
 194         if (ret) {
 195                 puts("Failed closing banks for reading!\n");
 196                 return ret;
 197         }
 198
 199         ret = mxs_ocotp_scale_hclk(1, &hclk_val);
 200         if (ret) {
 201                 puts("Failed scaling down the HCLK!\n");
 202                 return ret;
 203         }
 204         mxs_ocotp_scale_vddio(1, &vddio_val);
 205
 206         ret = mxs_ocotp_wait_busy_clear();
 207         if (ret) {
 208                 puts("Failed waiting for ready state!\n");
 209                 goto fail;
 210         }
 211
 212         /* Program the fuse address */
 213         writel(addr | OCOTP_CTRL_WR_UNLOCK_KEY, &ocotp_regs->hw_ocotp_ctrl);
 214
 215         /* Program the data. */
 216         writel(mask, &ocotp_regs->hw_ocotp_data);
 217
 218         udelay(10);
 219
 220         ret = mxs_ocotp_wait_busy_clear();
 221         if (ret) {
 222                 puts("Failed waiting for ready state!\n");
 223                 goto fail;
 224         }
 225
 226         /* Check for errors */
 227         if (readl(&ocotp_regs->hw_ocotp_ctrl) & OCOTP_CTRL_ERROR) {
 228                 puts("Failed writing fuses!\n");
 229                 ret = -EPERM;
 230                 goto fail;
 231         }
 232
 233 fail:
 234         mxs_ocotp_scale_vddio(0, &vddio_val);
 235         if (mxs_ocotp_scale_hclk(0, &hclk_val))
 236                 puts("Failed scaling up the HCLK!\n");
 237
 238         return ret;
 239 }
 240
 241 static int mxs_ocotp_read_fuse(uint32_t reg, uint32_t *val)
 242 {
 243         int ret;
 244
 245         /* Register offset from CUST0 */
 246         reg = ((uint32_t)&ocotp_regs->hw_ocotp_cust0) + (reg << 4);
 247
 248         ret = mxs_ocotp_wait_busy_clear();
 249         if (ret) {
 250                 puts("Failed waiting for ready state!\n");
 251                 return ret;
 252         }
 253
 254         mxs_ocotp_clear_error();
 255
 256         ret = mxs_ocotp_read_bank_open(1);
 257         if (ret) {
 258                 puts("Failed opening banks for reading!\n");
 259                 return ret;
 260         }
 261
 262         *val = readl(reg);
 263
 264         ret = mxs_ocotp_read_bank_open(0);
 265         if (ret) {
 266                 puts("Failed closing banks for reading!\n");
 267                 return ret;
 268         }
 269
 270         return ret;
 271 }
 272
 273 static int mxs_ocotp_valid(u32 bank, u32 word)
 274 {
 275         if (bank > 4)
 276                 return -EINVAL;
 277         if (word > 7)
 278                 return -EINVAL;
 279         return 0;
 280 }
 281
 282 /*
 283  * The 'fuse' command API
 284  */
 285 int fuse_read(u32 bank, u32 word, u32 *val)
 286 {
 287         int ret;
 288
 289         ret = mxs_ocotp_valid(bank, word);
 290         if (ret)
 291                 return ret;
 292
 293         return mxs_ocotp_read_fuse((bank << 3) | word, val);
 294 }
 295
 296 int fuse_prog(u32 bank, u32 word, u32 val)
 297 {
 298         int ret;
 299
 300         ret = mxs_ocotp_valid(bank, word);
 301         if (ret)
 302                 return ret;
 303
 304         return mxs_ocotp_write_fuse((bank << 3) | word, val);
 305 }
 306
 307 int fuse_sense(u32 bank, u32 word, u32 *val)
 308 {
 309         /* We do not support sensing :-( */
 310         return -EINVAL;
 311 }
 312
 313 int fuse_override(u32 bank, u32 word, u32 val)
 314 {
 315         /* We do not support overriding :-( */
 316         return -EINVAL;
 317 }