1 /* 2 * Freescale MXS On-Chip OTP driver 3 * 4 * Copyright (C) 2015 Stefan Wahren <stefan.wahren@i2se.com> 5 * 6 * Based on the driver from Huang Shijie and Christoph G. Baumann 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 */ 19 #include <linux/clk.h> 20 #include <linux/delay.h> 21 #include <linux/device.h> 22 #include <linux/err.h> 23 #include <linux/io.h> 24 #include <linux/module.h> 25 #include <linux/nvmem-provider.h> 26 #include <linux/of_device.h> 27 #include <linux/platform_device.h> 28 #include <linux/slab.h> 29 #include <linux/stmp_device.h> 30 31 /* OCOTP registers and bits */ 32 33 #define BM_OCOTP_CTRL_RD_BANK_OPEN BIT(12) 34 #define BM_OCOTP_CTRL_ERROR BIT(9) 35 #define BM_OCOTP_CTRL_BUSY BIT(8) 36 37 #define OCOTP_TIMEOUT 10000 38 #define OCOTP_DATA_OFFSET 0x20 39 40 struct mxs_ocotp { 41 struct clk *clk; 42 void __iomem *base; 43 struct nvmem_device *nvmem; 44 }; 45 46 static int mxs_ocotp_wait(struct mxs_ocotp *otp) 47 { 48 int timeout = OCOTP_TIMEOUT; 49 unsigned int status = 0; 50 51 while (timeout--) { 52 status = readl(otp->base); 53 54 if (!(status & (BM_OCOTP_CTRL_BUSY | BM_OCOTP_CTRL_ERROR))) 55 break; 56 57 cpu_relax(); 58 } 59 60 if (status & BM_OCOTP_CTRL_BUSY) 61 return -EBUSY; 62 else if (status & BM_OCOTP_CTRL_ERROR) 63 return -EIO; 64 65 return 0; 66 } 67 68 static int mxs_ocotp_read(void *context, unsigned int offset, 69 void *val, size_t bytes) 70 { 71 struct mxs_ocotp *otp = context; 72 u32 *buf = val; 73 int ret; 74 75 ret = clk_enable(otp->clk); 76 if (ret) 77 return ret; 78 79 writel(BM_OCOTP_CTRL_ERROR, otp->base + STMP_OFFSET_REG_CLR); 80 81 ret = mxs_ocotp_wait(otp); 82 if (ret) 83 goto disable_clk; 84 85 /* open OCOTP banks for read */ 86 writel(BM_OCOTP_CTRL_RD_BANK_OPEN, otp->base + STMP_OFFSET_REG_SET); 87 88 /* approximately wait 33 hclk cycles */ 89 udelay(1); 90 91 ret = mxs_ocotp_wait(otp); 92 if (ret) 93 goto close_banks; 94 95 while (bytes) { 96 if ((offset < OCOTP_DATA_OFFSET) || (offset % 16)) { 97 /* fill up non-data register */ 98 *buf++ = 0; 99 } else { 100 *buf++ = readl(otp->base + offset); 101 } 102 103 bytes -= 4; 104 offset += 4; 105 } 106 107 close_banks: 108 /* close banks for power saving */ 109 writel(BM_OCOTP_CTRL_RD_BANK_OPEN, otp->base + STMP_OFFSET_REG_CLR); 110 111 disable_clk: 112 clk_disable(otp->clk); 113 114 return ret; 115 } 116 117 static struct nvmem_config ocotp_config = { 118 .name = "mxs-ocotp", 119 .stride = 16, 120 .word_size = 4, 121 .reg_read = mxs_ocotp_read, 122 }; 123 124 struct mxs_data { 125 int size; 126 }; 127 128 static const struct mxs_data imx23_data = { 129 .size = 0x220, 130 }; 131 132 static const struct mxs_data imx28_data = { 133 .size = 0x2a0, 134 }; 135 136 static const struct of_device_id mxs_ocotp_match[] = { 137 { .compatible = "fsl,imx23-ocotp", .data = &imx23_data }, 138 { .compatible = "fsl,imx28-ocotp", .data = &imx28_data }, 139 { /* sentinel */}, 140 }; 141 MODULE_DEVICE_TABLE(of, mxs_ocotp_match); 142 143 static int mxs_ocotp_probe(struct platform_device *pdev) 144 { 145 struct device *dev = &pdev->dev; 146 const struct mxs_data *data; 147 struct mxs_ocotp *otp; 148 struct resource *res; 149 const struct of_device_id *match; 150 int ret; 151 152 match = of_match_device(dev->driver->of_match_table, dev); 153 if (!match || !match->data) 154 return -EINVAL; 155 156 otp = devm_kzalloc(dev, sizeof(*otp), GFP_KERNEL); 157 if (!otp) 158 return -ENOMEM; 159 160 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 161 otp->base = devm_ioremap_resource(dev, res); 162 if (IS_ERR(otp->base)) 163 return PTR_ERR(otp->base); 164 165 otp->clk = devm_clk_get(&pdev->dev, NULL); 166 if (IS_ERR(otp->clk)) 167 return PTR_ERR(otp->clk); 168 169 ret = clk_prepare(otp->clk); 170 if (ret < 0) { 171 dev_err(dev, "failed to prepare clk: %d\n", ret); 172 return ret; 173 } 174 175 data = match->data; 176 177 ocotp_config.size = data->size; 178 ocotp_config.priv = otp; 179 ocotp_config.dev = dev; 180 otp->nvmem = nvmem_register(&ocotp_config); 181 if (IS_ERR(otp->nvmem)) { 182 ret = PTR_ERR(otp->nvmem); 183 goto err_clk; 184 } 185 186 platform_set_drvdata(pdev, otp); 187 188 return 0; 189 190 err_clk: 191 clk_unprepare(otp->clk); 192 193 return ret; 194 } 195 196 static int mxs_ocotp_remove(struct platform_device *pdev) 197 { 198 struct mxs_ocotp *otp = platform_get_drvdata(pdev); 199 200 clk_unprepare(otp->clk); 201 202 return nvmem_unregister(otp->nvmem); 203 } 204 205 static struct platform_driver mxs_ocotp_driver = { 206 .probe = mxs_ocotp_probe, 207 .remove = mxs_ocotp_remove, 208 .driver = { 209 .name = "mxs-ocotp", 210 .of_match_table = mxs_ocotp_match, 211 }, 212 }; 213 214 module_platform_driver(mxs_ocotp_driver); 215 MODULE_AUTHOR("Stefan Wahren <stefan.wahren@i2se.com>"); 216 MODULE_DESCRIPTION("driver for OCOTP in i.MX23/i.MX28"); 217 MODULE_LICENSE("GPL v2"); 218