1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * OTP support for SPI NOR flashes 4 * 5 * Copyright (C) 2021 Michael Walle <michael@walle.cc> 6 */ 7 8 #include <linux/log2.h> 9 #include <linux/mtd/mtd.h> 10 #include <linux/mtd/spi-nor.h> 11 12 #include "core.h" 13 14 #define spi_nor_otp_region_len(nor) ((nor)->params->otp.org->len) 15 #define spi_nor_otp_n_regions(nor) ((nor)->params->otp.org->n_regions) 16 17 /** 18 * spi_nor_otp_read_secr() - read security register 19 * @nor: pointer to 'struct spi_nor' 20 * @addr: offset to read from 21 * @len: number of bytes to read 22 * @buf: pointer to dst buffer 23 * 24 * Read a security register by using the SPINOR_OP_RSECR commands. 25 * 26 * In Winbond/GigaDevice datasheets the term "security register" stands for 27 * an one-time-programmable memory area, consisting of multiple bytes (usually 28 * 256). Thus one "security register" maps to one OTP region. 29 * 30 * This method is used on GigaDevice and Winbond flashes. 31 * 32 * Please note, the read must not span multiple registers. 33 * 34 * Return: number of bytes read successfully, -errno otherwise 35 */ 36 int spi_nor_otp_read_secr(struct spi_nor *nor, loff_t addr, size_t len, u8 *buf) 37 { 38 u8 addr_width, read_opcode, read_dummy; 39 struct spi_mem_dirmap_desc *rdesc; 40 enum spi_nor_protocol read_proto; 41 int ret; 42 43 read_opcode = nor->read_opcode; 44 addr_width = nor->addr_width; 45 read_dummy = nor->read_dummy; 46 read_proto = nor->read_proto; 47 rdesc = nor->dirmap.rdesc; 48 49 nor->read_opcode = SPINOR_OP_RSECR; 50 nor->read_dummy = 8; 51 nor->read_proto = SNOR_PROTO_1_1_1; 52 nor->dirmap.rdesc = NULL; 53 54 ret = spi_nor_read_data(nor, addr, len, buf); 55 56 nor->read_opcode = read_opcode; 57 nor->addr_width = addr_width; 58 nor->read_dummy = read_dummy; 59 nor->read_proto = read_proto; 60 nor->dirmap.rdesc = rdesc; 61 62 return ret; 63 } 64 65 /** 66 * spi_nor_otp_write_secr() - write security register 67 * @nor: pointer to 'struct spi_nor' 68 * @addr: offset to write to 69 * @len: number of bytes to write 70 * @buf: pointer to src buffer 71 * 72 * Write a security register by using the SPINOR_OP_PSECR commands. 73 * 74 * For more information on the term "security register", see the documentation 75 * of spi_nor_otp_read_secr(). 76 * 77 * This method is used on GigaDevice and Winbond flashes. 78 * 79 * Please note, the write must not span multiple registers. 80 * 81 * Return: number of bytes written successfully, -errno otherwise 82 */ 83 int spi_nor_otp_write_secr(struct spi_nor *nor, loff_t addr, size_t len, 84 const u8 *buf) 85 { 86 enum spi_nor_protocol write_proto; 87 struct spi_mem_dirmap_desc *wdesc; 88 u8 addr_width, program_opcode; 89 int ret, written; 90 91 program_opcode = nor->program_opcode; 92 addr_width = nor->addr_width; 93 write_proto = nor->write_proto; 94 wdesc = nor->dirmap.wdesc; 95 96 nor->program_opcode = SPINOR_OP_PSECR; 97 nor->write_proto = SNOR_PROTO_1_1_1; 98 nor->dirmap.wdesc = NULL; 99 100 /* 101 * We only support a write to one single page. For now all winbond 102 * flashes only have one page per security register. 103 */ 104 ret = spi_nor_write_enable(nor); 105 if (ret) 106 goto out; 107 108 written = spi_nor_write_data(nor, addr, len, buf); 109 if (written < 0) 110 goto out; 111 112 ret = spi_nor_wait_till_ready(nor); 113 114 out: 115 nor->program_opcode = program_opcode; 116 nor->addr_width = addr_width; 117 nor->write_proto = write_proto; 118 nor->dirmap.wdesc = wdesc; 119 120 return ret ?: written; 121 } 122 123 static int spi_nor_otp_lock_bit_cr(unsigned int region) 124 { 125 static const int lock_bits[] = { SR2_LB1, SR2_LB2, SR2_LB3 }; 126 127 if (region >= ARRAY_SIZE(lock_bits)) 128 return -EINVAL; 129 130 return lock_bits[region]; 131 } 132 133 /** 134 * spi_nor_otp_lock_sr2() - lock the OTP region 135 * @nor: pointer to 'struct spi_nor' 136 * @region: OTP region 137 * 138 * Lock the OTP region by writing the status register-2. This method is used on 139 * GigaDevice and Winbond flashes. 140 * 141 * Return: 0 on success, -errno otherwise. 142 */ 143 int spi_nor_otp_lock_sr2(struct spi_nor *nor, unsigned int region) 144 { 145 u8 *cr = nor->bouncebuf; 146 int ret, lock_bit; 147 148 lock_bit = spi_nor_otp_lock_bit_cr(region); 149 if (lock_bit < 0) 150 return lock_bit; 151 152 ret = spi_nor_read_cr(nor, cr); 153 if (ret) 154 return ret; 155 156 /* no need to write the register if region is already locked */ 157 if (cr[0] & lock_bit) 158 return 0; 159 160 cr[0] |= lock_bit; 161 162 return spi_nor_write_16bit_cr_and_check(nor, cr[0]); 163 } 164 165 /** 166 * spi_nor_otp_is_locked_sr2() - get the OTP region lock status 167 * @nor: pointer to 'struct spi_nor' 168 * @region: OTP region 169 * 170 * Retrieve the OTP region lock bit by reading the status register-2. This 171 * method is used on GigaDevice and Winbond flashes. 172 * 173 * Return: 0 on success, -errno otherwise. 174 */ 175 int spi_nor_otp_is_locked_sr2(struct spi_nor *nor, unsigned int region) 176 { 177 u8 *cr = nor->bouncebuf; 178 int ret, lock_bit; 179 180 lock_bit = spi_nor_otp_lock_bit_cr(region); 181 if (lock_bit < 0) 182 return lock_bit; 183 184 ret = spi_nor_read_cr(nor, cr); 185 if (ret) 186 return ret; 187 188 return cr[0] & lock_bit; 189 } 190 191 static loff_t spi_nor_otp_region_start(const struct spi_nor *nor, unsigned int region) 192 { 193 const struct spi_nor_otp_organization *org = nor->params->otp.org; 194 195 return org->base + region * org->offset; 196 } 197 198 static size_t spi_nor_otp_size(struct spi_nor *nor) 199 { 200 return spi_nor_otp_n_regions(nor) * spi_nor_otp_region_len(nor); 201 } 202 203 /* Translate the file offsets from and to OTP regions. */ 204 static loff_t spi_nor_otp_region_to_offset(struct spi_nor *nor, unsigned int region) 205 { 206 return region * spi_nor_otp_region_len(nor); 207 } 208 209 static unsigned int spi_nor_otp_offset_to_region(struct spi_nor *nor, loff_t ofs) 210 { 211 return div64_u64(ofs, spi_nor_otp_region_len(nor)); 212 } 213 214 static int spi_nor_mtd_otp_info(struct mtd_info *mtd, size_t len, 215 size_t *retlen, struct otp_info *buf) 216 { 217 struct spi_nor *nor = mtd_to_spi_nor(mtd); 218 const struct spi_nor_otp_ops *ops = nor->params->otp.ops; 219 unsigned int n_regions = spi_nor_otp_n_regions(nor); 220 unsigned int i; 221 int ret, locked; 222 223 if (len < n_regions * sizeof(*buf)) 224 return -ENOSPC; 225 226 ret = spi_nor_lock_and_prep(nor); 227 if (ret) 228 return ret; 229 230 for (i = 0; i < n_regions; i++) { 231 buf->start = spi_nor_otp_region_to_offset(nor, i); 232 buf->length = spi_nor_otp_region_len(nor); 233 234 locked = ops->is_locked(nor, i); 235 if (locked < 0) { 236 ret = locked; 237 goto out; 238 } 239 240 buf->locked = !!locked; 241 buf++; 242 } 243 244 *retlen = n_regions * sizeof(*buf); 245 246 out: 247 spi_nor_unlock_and_unprep(nor); 248 249 return ret; 250 } 251 252 static int spi_nor_mtd_otp_read_write(struct mtd_info *mtd, loff_t ofs, 253 size_t total_len, size_t *retlen, 254 const u8 *buf, bool is_write) 255 { 256 struct spi_nor *nor = mtd_to_spi_nor(mtd); 257 const struct spi_nor_otp_ops *ops = nor->params->otp.ops; 258 const size_t rlen = spi_nor_otp_region_len(nor); 259 loff_t rstart, rofs; 260 unsigned int region; 261 size_t len; 262 int ret; 263 264 if (ofs < 0 || ofs >= spi_nor_otp_size(nor)) 265 return 0; 266 267 ret = spi_nor_lock_and_prep(nor); 268 if (ret) 269 return ret; 270 271 /* don't access beyond the end */ 272 total_len = min_t(size_t, total_len, spi_nor_otp_size(nor) - ofs); 273 274 *retlen = 0; 275 while (total_len) { 276 /* 277 * The OTP regions are mapped into a contiguous area starting 278 * at 0 as expected by the MTD layer. This will map the MTD 279 * file offsets to the address of an OTP region as used in the 280 * actual SPI commands. 281 */ 282 region = spi_nor_otp_offset_to_region(nor, ofs); 283 rstart = spi_nor_otp_region_start(nor, region); 284 285 /* 286 * The size of a OTP region is expected to be a power of two, 287 * thus we can just mask the lower bits and get the offset into 288 * a region. 289 */ 290 rofs = ofs & (rlen - 1); 291 292 /* don't access beyond one OTP region */ 293 len = min_t(size_t, total_len, rlen - rofs); 294 295 if (is_write) 296 ret = ops->write(nor, rstart + rofs, len, buf); 297 else 298 ret = ops->read(nor, rstart + rofs, len, (u8 *)buf); 299 if (ret == 0) 300 ret = -EIO; 301 if (ret < 0) 302 goto out; 303 304 *retlen += ret; 305 ofs += ret; 306 buf += ret; 307 total_len -= ret; 308 } 309 ret = 0; 310 311 out: 312 spi_nor_unlock_and_unprep(nor); 313 return ret; 314 } 315 316 static int spi_nor_mtd_otp_read(struct mtd_info *mtd, loff_t from, size_t len, 317 size_t *retlen, u8 *buf) 318 { 319 return spi_nor_mtd_otp_read_write(mtd, from, len, retlen, buf, false); 320 } 321 322 static int spi_nor_mtd_otp_write(struct mtd_info *mtd, loff_t to, size_t len, 323 size_t *retlen, const u8 *buf) 324 { 325 return spi_nor_mtd_otp_read_write(mtd, to, len, retlen, buf, true); 326 } 327 328 static int spi_nor_mtd_otp_lock(struct mtd_info *mtd, loff_t from, size_t len) 329 { 330 struct spi_nor *nor = mtd_to_spi_nor(mtd); 331 const struct spi_nor_otp_ops *ops = nor->params->otp.ops; 332 const size_t rlen = spi_nor_otp_region_len(nor); 333 unsigned int region; 334 int ret; 335 336 if (from < 0 || (from + len) > spi_nor_otp_size(nor)) 337 return -EINVAL; 338 339 /* the user has to explicitly ask for whole regions */ 340 if (!IS_ALIGNED(len, rlen) || !IS_ALIGNED(from, rlen)) 341 return -EINVAL; 342 343 ret = spi_nor_lock_and_prep(nor); 344 if (ret) 345 return ret; 346 347 while (len) { 348 region = spi_nor_otp_offset_to_region(nor, from); 349 ret = ops->lock(nor, region); 350 if (ret) 351 goto out; 352 353 len -= rlen; 354 from += rlen; 355 } 356 357 out: 358 spi_nor_unlock_and_unprep(nor); 359 360 return ret; 361 } 362 363 void spi_nor_otp_init(struct spi_nor *nor) 364 { 365 struct mtd_info *mtd = &nor->mtd; 366 367 if (!nor->params->otp.ops) 368 return; 369 370 if (WARN_ON(!is_power_of_2(spi_nor_otp_region_len(nor)))) 371 return; 372 373 /* 374 * We only support user_prot callbacks (yet). 375 * 376 * Some SPI NOR flashes like Macronix ones can be ordered in two 377 * different variants. One with a factory locked OTP area and one where 378 * it is left to the user to write to it. The factory locked OTP is 379 * usually preprogrammed with an "electrical serial number". We don't 380 * support these for now. 381 */ 382 mtd->_get_user_prot_info = spi_nor_mtd_otp_info; 383 mtd->_read_user_prot_reg = spi_nor_mtd_otp_read; 384 mtd->_write_user_prot_reg = spi_nor_mtd_otp_write; 385 mtd->_lock_user_prot_reg = spi_nor_mtd_otp_lock; 386 } 387