drivers/mtd/spi-nor/core.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Based on m25p80.c, by Mike Lavender (mike@steroidmicros.com), with
   4  * influence from lart.c (Abraham Van Der Merwe) and mtd_dataflash.c
   5  *
   6  * Copyright (C) 2005, Intec Automation Inc.
   7  * Copyright (C) 2014, Freescale Semiconductor, Inc.
   8  */
   9
  10 #include <linux/err.h>
  11 #include <linux/errno.h>
  12 #include <linux/module.h>
  13 #include <linux/device.h>
  14 #include <linux/mutex.h>
  15 #include <linux/math64.h>
  16 #include <linux/sizes.h>
  17 #include <linux/slab.h>
  18
  19 #include <linux/mtd/mtd.h>
  20 #include <linux/of_platform.h>
  21 #include <linux/sched/task_stack.h>
  22 #include <linux/spi/flash.h>
  23 #include <linux/mtd/spi-nor.h>
  24
  25 #include "core.h"
  26
  27 /* Define max times to check status register before we give up. */
  28
  29 /*
  30  * For everything but full-chip erase; probably could be much smaller, but kept
  31  * around for safety for now
  32  */
  33 #define DEFAULT_READY_WAIT_JIFFIES              (40UL * HZ)
  34
  35 /*
  36  * For full-chip erase, calibrated to a 2MB flash (M25P16); should be scaled up
  37  * for larger flash
  38  */
  39 #define CHIP_ERASE_2MB_READY_WAIT_JIFFIES       (40UL * HZ)
  40
  41 #define SPI_NOR_MAX_ADDR_WIDTH  4
  42
  43 /**
  44  * spi_nor_spimem_bounce() - check if a bounce buffer is needed for the data
  45  *                           transfer
  46  * @nor:        pointer to 'struct spi_nor'
  47  * @op:         pointer to 'struct spi_mem_op' template for transfer
  48  *
  49  * If we have to use the bounce buffer, the data field in @op will be updated.
  50  *
  51  * Return: true if the bounce buffer is needed, false if not
  52  */
  53 static bool spi_nor_spimem_bounce(struct spi_nor *nor, struct spi_mem_op *op)
  54 {
  55         /* op->data.buf.in occupies the same memory as op->data.buf.out */
  56         if (object_is_on_stack(op->data.buf.in) ||
  57             !virt_addr_valid(op->data.buf.in)) {
  58                 if (op->data.nbytes > nor->bouncebuf_size)
  59                         op->data.nbytes = nor->bouncebuf_size;
  60                 op->data.buf.in = nor->bouncebuf;
  61                 return true;
  62         }
  63
  64         return false;
  65 }
  66
  67 /**
  68  * spi_nor_spimem_exec_op() - execute a memory operation
  69  * @nor:        pointer to 'struct spi_nor'
  70  * @op:         pointer to 'struct spi_mem_op' template for transfer
  71  *
  72  * Return: 0 on success, -error otherwise.
  73  */
  74 static int spi_nor_spimem_exec_op(struct spi_nor *nor, struct spi_mem_op *op)
  75 {
  76         int error;
  77
  78         error = spi_mem_adjust_op_size(nor->spimem, op);
  79         if (error)
  80                 return error;
  81
  82         return spi_mem_exec_op(nor->spimem, op);
  83 }
  84
  85 /**
  86  * spi_nor_spimem_read_data() - read data from flash's memory region via
  87  *                              spi-mem
  88  * @nor:        pointer to 'struct spi_nor'
  89  * @from:       offset to read from
  90  * @len:        number of bytes to read
  91  * @buf:        pointer to dst buffer
  92  *
  93  * Return: number of bytes read successfully, -errno otherwise
  94  */
  95 static ssize_t spi_nor_spimem_read_data(struct spi_nor *nor, loff_t from,
  96                                         size_t len, u8 *buf)
  97 {
  98         struct spi_mem_op op =
  99                 SPI_MEM_OP(SPI_MEM_OP_CMD(nor->read_opcode, 1),
 100                            SPI_MEM_OP_ADDR(nor->addr_width, from, 1),
 101                            SPI_MEM_OP_DUMMY(nor->read_dummy, 1),
 102                            SPI_MEM_OP_DATA_IN(len, buf, 1));
 103         bool usebouncebuf;
 104         ssize_t nbytes;
 105         int error;
 106
 107         /* get transfer protocols. */
 108         op.cmd.buswidth = spi_nor_get_protocol_inst_nbits(nor->read_proto);
 109         op.addr.buswidth = spi_nor_get_protocol_addr_nbits(nor->read_proto);
 110         op.dummy.buswidth = op.addr.buswidth;
 111         op.data.buswidth = spi_nor_get_protocol_data_nbits(nor->read_proto);
 112
 113         /* convert the dummy cycles to the number of bytes */
 114         op.dummy.nbytes = (nor->read_dummy * op.dummy.buswidth) / 8;
 115
 116         usebouncebuf = spi_nor_spimem_bounce(nor, &op);
 117
 118         if (nor->dirmap.rdesc) {
 119                 nbytes = spi_mem_dirmap_read(nor->dirmap.rdesc, op.addr.val,
 120                                              op.data.nbytes, op.data.buf.in);
 121         } else {
 122                 error = spi_nor_spimem_exec_op(nor, &op);
 123                 if (error)
 124                         return error;
 125                 nbytes = op.data.nbytes;
 126         }
 127
 128         if (usebouncebuf && nbytes > 0)
 129                 memcpy(buf, op.data.buf.in, nbytes);
 130
 131         return nbytes;
 132 }
 133
 134 /**
 135  * spi_nor_read_data() - read data from flash memory
 136  * @nor:        pointer to 'struct spi_nor'
 137  * @from:       offset to read from
 138  * @len:        number of bytes to read
 139  * @buf:        pointer to dst buffer
 140  *
 141  * Return: number of bytes read successfully, -errno otherwise
 142  */
 143 ssize_t spi_nor_read_data(struct spi_nor *nor, loff_t from, size_t len, u8 *buf)
 144 {
 145         if (nor->spimem)
 146                 return spi_nor_spimem_read_data(nor, from, len, buf);
 147
 148         return nor->controller_ops->read(nor, from, len, buf);
 149 }
 150
 151 /**
 152  * spi_nor_spimem_write_data() - write data to flash memory via
 153  *                               spi-mem
 154  * @nor:        pointer to 'struct spi_nor'
 155  * @to:         offset to write to
 156  * @len:        number of bytes to write
 157  * @buf:        pointer to src buffer
 158  *
 159  * Return: number of bytes written successfully, -errno otherwise
 160  */
 161 static ssize_t spi_nor_spimem_write_data(struct spi_nor *nor, loff_t to,
 162                                          size_t len, const u8 *buf)
 163 {
 164         struct spi_mem_op op =
 165                 SPI_MEM_OP(SPI_MEM_OP_CMD(nor->program_opcode, 1),
 166                            SPI_MEM_OP_ADDR(nor->addr_width, to, 1),
 167                            SPI_MEM_OP_NO_DUMMY,
 168                            SPI_MEM_OP_DATA_OUT(len, buf, 1));
 169         ssize_t nbytes;
 170         int error;
 171
 172         op.cmd.buswidth = spi_nor_get_protocol_inst_nbits(nor->write_proto);
 173         op.addr.buswidth = spi_nor_get_protocol_addr_nbits(nor->write_proto);
 174         op.data.buswidth = spi_nor_get_protocol_data_nbits(nor->write_proto);
 175
 176         if (nor->program_opcode == SPINOR_OP_AAI_WP && nor->sst_write_second)
 177                 op.addr.nbytes = 0;
 178
 179         if (spi_nor_spimem_bounce(nor, &op))
 180                 memcpy(nor->bouncebuf, buf, op.data.nbytes);
 181
 182         if (nor->dirmap.wdesc) {
 183                 nbytes = spi_mem_dirmap_write(nor->dirmap.wdesc, op.addr.val,
 184                                               op.data.nbytes, op.data.buf.out);
 185         } else {
 186                 error = spi_nor_spimem_exec_op(nor, &op);
 187                 if (error)
 188                         return error;
 189                 nbytes = op.data.nbytes;
 190         }
 191
 192         return nbytes;
 193 }
 194
 195 /**
 196  * spi_nor_write_data() - write data to flash memory
 197  * @nor:        pointer to 'struct spi_nor'
 198  * @to:         offset to write to
 199  * @len:        number of bytes to write
 200  * @buf:        pointer to src buffer
 201  *
 202  * Return: number of bytes written successfully, -errno otherwise
 203  */
 204 ssize_t spi_nor_write_data(struct spi_nor *nor, loff_t to, size_t len,
 205                            const u8 *buf)
 206 {
 207         if (nor->spimem)
 208                 return spi_nor_spimem_write_data(nor, to, len, buf);
 209
 210         return nor->controller_ops->write(nor, to, len, buf);
 211 }
 212
 213 /**
 214  * spi_nor_write_enable() - Set write enable latch with Write Enable command.
 215  * @nor:        pointer to 'struct spi_nor'.
 216  *
 217  * Return: 0 on success, -errno otherwise.
 218  */
 219 int spi_nor_write_enable(struct spi_nor *nor)
 220 {
 221         int ret;
 222
 223         if (nor->spimem) {
 224                 struct spi_mem_op op =
 225                         SPI_MEM_OP(SPI_MEM_OP_CMD(SPINOR_OP_WREN, 1),
 226                                    SPI_MEM_OP_NO_ADDR,
 227                                    SPI_MEM_OP_NO_DUMMY,
 228                                    SPI_MEM_OP_NO_DATA);
 229
 230                 ret = spi_mem_exec_op(nor->spimem, &op);
 231         } else {
 232                 ret = nor->controller_ops->write_reg(nor, SPINOR_OP_WREN,
 233                                                      NULL, 0);
 234         }
 235
 236         if (ret)
 237                 dev_dbg(nor->dev, "error %d on Write Enable\n", ret);
 238
 239         return ret;
 240 }
 241
 242 /**
 243  * spi_nor_write_disable() - Send Write Disable instruction to the chip.
 244  * @nor:        pointer to 'struct spi_nor'.
 245  *
 246  * Return: 0 on success, -errno otherwise.
 247  */
 248 int spi_nor_write_disable(struct spi_nor *nor)
 249 {
 250         int ret;
 251
 252         if (nor->spimem) {
 253                 struct spi_mem_op op =
 254                         SPI_MEM_OP(SPI_MEM_OP_CMD(SPINOR_OP_WRDI, 1),
 255                                    SPI_MEM_OP_NO_ADDR,
 256                                    SPI_MEM_OP_NO_DUMMY,
 257                                    SPI_MEM_OP_NO_DATA);
 258
 259                 ret = spi_mem_exec_op(nor->spimem, &op);
 260         } else {
 261                 ret = nor->controller_ops->write_reg(nor, SPINOR_OP_WRDI,
 262                                                      NULL, 0);
 263         }
 264
 265         if (ret)
 266                 dev_dbg(nor->dev, "error %d on Write Disable\n", ret);
 267
 268         return ret;
 269 }
 270
 271 /**
 272  * spi_nor_read_sr() - Read the Status Register.
 273  * @nor:        pointer to 'struct spi_nor'.
 274  * @sr:         pointer to a DMA-able buffer where the value of the
 275  *              Status Register will be written.
 276  *
 277  * Return: 0 on success, -errno otherwise.
 278  */
 279 static int spi_nor_read_sr(struct spi_nor *nor, u8 *sr)
 280 {
 281         int ret;
 282
 283         if (nor->spimem) {
 284                 struct spi_mem_op op =
 285                         SPI_MEM_OP(SPI_MEM_OP_CMD(SPINOR_OP_RDSR, 1),
 286                                    SPI_MEM_OP_NO_ADDR,
 287                                    SPI_MEM_OP_NO_DUMMY,
 288                                    SPI_MEM_OP_DATA_IN(1, sr, 1));
 289
 290                 ret = spi_mem_exec_op(nor->spimem, &op);
 291         } else {
 292                 ret = nor->controller_ops->read_reg(nor, SPINOR_OP_RDSR,
 293                                                     sr, 1);
 294         }
 295
 296         if (ret)
 297                 dev_dbg(nor->dev, "error %d reading SR\n", ret);
 298
 299         return ret;
 300 }
 301
 302 /**
 303  * spi_nor_read_fsr() - Read the Flag Status Register.
 304  * @nor:        pointer to 'struct spi_nor'
 305  * @fsr:        pointer to a DMA-able buffer where the value of the
 306  *              Flag Status Register will be written.
 307  *
 308  * Return: 0 on success, -errno otherwise.
 309  */
 310 static int spi_nor_read_fsr(struct spi_nor *nor, u8 *fsr)
 311 {
 312         int ret;
 313
 314         if (nor->spimem) {
 315                 struct spi_mem_op op =
 316                         SPI_MEM_OP(SPI_MEM_OP_CMD(SPINOR_OP_RDFSR, 1),
 317                                    SPI_MEM_OP_NO_ADDR,
 318                                    SPI_MEM_OP_NO_DUMMY,
 319                                    SPI_MEM_OP_DATA_IN(1, fsr, 1));
 320
 321                 ret = spi_mem_exec_op(nor->spimem, &op);
 322         } else {
 323                 ret = nor->controller_ops->read_reg(nor, SPINOR_OP_RDFSR,
 324                                                     fsr, 1);
 325         }
 326
 327         if (ret)
 328                 dev_dbg(nor->dev, "error %d reading FSR\n", ret);
 329
 330         return ret;
 331 }
 332
 333 /**
 334  * spi_nor_read_cr() - Read the Configuration Register using the
 335  * SPINOR_OP_RDCR (35h) command.
 336  * @nor:        pointer to 'struct spi_nor'
 337  * @cr:         pointer to a DMA-able buffer where the value of the
 338  *              Configuration Register will be written.
 339  *
 340  * Return: 0 on success, -errno otherwise.
 341  */
 342 static int spi_nor_read_cr(struct spi_nor *nor, u8 *cr)
 343 {
 344         int ret;
 345
 346         if (nor->spimem) {
 347                 struct spi_mem_op op =
 348                         SPI_MEM_OP(SPI_MEM_OP_CMD(SPINOR_OP_RDCR, 1),
 349                                    SPI_MEM_OP_NO_ADDR,
 350                                    SPI_MEM_OP_NO_DUMMY,
 351                                    SPI_MEM_OP_DATA_IN(1, cr, 1));
 352
 353                 ret = spi_mem_exec_op(nor->spimem, &op);
 354         } else {
 355                 ret = nor->controller_ops->read_reg(nor, SPINOR_OP_RDCR, cr, 1);
 356         }
 357
 358         if (ret)
 359                 dev_dbg(nor->dev, "error %d reading CR\n", ret);
 360
 361         return ret;
 362 }
 363
 364 /**
 365  * spi_nor_set_4byte_addr_mode() - Enter/Exit 4-byte address mode.
 366  * @nor:        pointer to 'struct spi_nor'.
 367  * @enable:     true to enter the 4-byte address mode, false to exit the 4-byte
 368  *              address mode.
 369  *
 370  * Return: 0 on success, -errno otherwise.
 371  */
 372 int spi_nor_set_4byte_addr_mode(struct spi_nor *nor, bool enable)
 373 {
 374         int ret;
 375
 376         if (nor->spimem) {
 377                 struct spi_mem_op op =
 378                         SPI_MEM_OP(SPI_MEM_OP_CMD(enable ?
 379                                                   SPINOR_OP_EN4B :
 380                                                   SPINOR_OP_EX4B,
 381                                                   1),
 382                                   SPI_MEM_OP_NO_ADDR,
 383                                   SPI_MEM_OP_NO_DUMMY,
 384                                   SPI_MEM_OP_NO_DATA);
 385
 386                 ret = spi_mem_exec_op(nor->spimem, &op);
 387         } else {
 388                 ret = nor->controller_ops->write_reg(nor,
 389                                                      enable ? SPINOR_OP_EN4B :
 390                                                               SPINOR_OP_EX4B,
 391                                                      NULL, 0);
 392         }
 393
 394         if (ret)
 395                 dev_dbg(nor->dev, "error %d setting 4-byte mode\n", ret);
 396
 397         return ret;
 398 }
 399
 400 /**
 401  * spansion_set_4byte_addr_mode() - Set 4-byte address mode for Spansion
 402  * flashes.
 403  * @nor:        pointer to 'struct spi_nor'.
 404  * @enable:     true to enter the 4-byte address mode, false to exit the 4-byte
 405  *              address mode.
 406  *
 407  * Return: 0 on success, -errno otherwise.
 408  */
 409 static int spansion_set_4byte_addr_mode(struct spi_nor *nor, bool enable)
 410 {
 411         int ret;
 412
 413         nor->bouncebuf[0] = enable << 7;
 414
 415         if (nor->spimem) {
 416                 struct spi_mem_op op =
 417                         SPI_MEM_OP(SPI_MEM_OP_CMD(SPINOR_OP_BRWR, 1),
 418                                    SPI_MEM_OP_NO_ADDR,
 419                                    SPI_MEM_OP_NO_DUMMY,
 420                                    SPI_MEM_OP_DATA_OUT(1, nor->bouncebuf, 1));
 421
 422                 ret = spi_mem_exec_op(nor->spimem, &op);
 423         } else {
 424                 ret = nor->controller_ops->write_reg(nor, SPINOR_OP_BRWR,
 425                                                      nor->bouncebuf, 1);
 426         }
 427
 428         if (ret)
 429                 dev_dbg(nor->dev, "error %d setting 4-byte mode\n", ret);
 430
 431         return ret;
 432 }
 433
 434 /**
 435  * spi_nor_write_ear() - Write Extended Address Register.
 436  * @nor:        pointer to 'struct spi_nor'.
 437  * @ear:        value to write to the Extended Address Register.
 438  *
 439  * Return: 0 on success, -errno otherwise.
 440  */
 441 int spi_nor_write_ear(struct spi_nor *nor, u8 ear)
 442 {
 443         int ret;
 444
 445         nor->bouncebuf[0] = ear;
 446
 447         if (nor->spimem) {
 448                 struct spi_mem_op op =
 449                         SPI_MEM_OP(SPI_MEM_OP_CMD(SPINOR_OP_WREAR, 1),
 450                                    SPI_MEM_OP_NO_ADDR,
 451                                    SPI_MEM_OP_NO_DUMMY,
 452                                    SPI_MEM_OP_DATA_OUT(1, nor->bouncebuf, 1));
 453
 454                 ret = spi_mem_exec_op(nor->spimem, &op);
 455         } else {
 456                 ret = nor->controller_ops->write_reg(nor, SPINOR_OP_WREAR,
 457                                                      nor->bouncebuf, 1);
 458         }
 459
 460         if (ret)
 461                 dev_dbg(nor->dev, "error %d writing EAR\n", ret);
 462
 463         return ret;
 464 }
 465
 466 /**
 467  * spi_nor_xread_sr() - Read the Status Register on S3AN flashes.
 468  * @nor:        pointer to 'struct spi_nor'.
 469  * @sr:         pointer to a DMA-able buffer where the value of the
 470  *              Status Register will be written.
 471  *
 472  * Return: 0 on success, -errno otherwise.
 473  */
 474 int spi_nor_xread_sr(struct spi_nor *nor, u8 *sr)
 475 {
 476         int ret;
 477
 478         if (nor->spimem) {
 479                 struct spi_mem_op op =
 480                         SPI_MEM_OP(SPI_MEM_OP_CMD(SPINOR_OP_XRDSR, 1),
 481                                    SPI_MEM_OP_NO_ADDR,
 482                                    SPI_MEM_OP_NO_DUMMY,
 483                                    SPI_MEM_OP_DATA_IN(1, sr, 1));
 484
 485                 ret = spi_mem_exec_op(nor->spimem, &op);
 486         } else {
 487                 ret = nor->controller_ops->read_reg(nor, SPINOR_OP_XRDSR,
 488                                                     sr, 1);
 489         }
 490
 491         if (ret)
 492                 dev_dbg(nor->dev, "error %d reading XRDSR\n", ret);
 493
 494         return ret;
 495 }
 496
 497 /**
 498  * spi_nor_xsr_ready() - Query the Status Register of the S3AN flash to see if
 499  * the flash is ready for new commands.
 500  * @nor:        pointer to 'struct spi_nor'.
 501  *
 502  * Return: 1 if ready, 0 if not ready, -errno on errors.
 503  */
 504 static int spi_nor_xsr_ready(struct spi_nor *nor)
 505 {
 506         int ret;
 507
 508         ret = spi_nor_xread_sr(nor, nor->bouncebuf);
 509         if (ret)
 510                 return ret;
 511
 512         return !!(nor->bouncebuf[0] & XSR_RDY);
 513 }
 514
 515 /**
 516  * spi_nor_clear_sr() - Clear the Status Register.
 517  * @nor:        pointer to 'struct spi_nor'.
 518  */
 519 static void spi_nor_clear_sr(struct spi_nor *nor)
 520 {
 521         int ret;
 522
 523         if (nor->spimem) {
 524                 struct spi_mem_op op =
 525                         SPI_MEM_OP(SPI_MEM_OP_CMD(SPINOR_OP_CLSR, 1),
 526                                    SPI_MEM_OP_NO_ADDR,
 527                                    SPI_MEM_OP_NO_DUMMY,
 528                                    SPI_MEM_OP_NO_DATA);
 529
 530                 ret = spi_mem_exec_op(nor->spimem, &op);
 531         } else {
 532                 ret = nor->controller_ops->write_reg(nor, SPINOR_OP_CLSR,
 533                                                      NULL, 0);
 534         }
 535
 536         if (ret)
 537                 dev_dbg(nor->dev, "error %d clearing SR\n", ret);
 538 }
 539
 540 /**
 541  * spi_nor_sr_ready() - Query the Status Register to see if the flash is ready
 542  * for new commands.
 543  * @nor:        pointer to 'struct spi_nor'.
 544  *
 545  * Return: 1 if ready, 0 if not ready, -errno on errors.
 546  */
 547 static int spi_nor_sr_ready(struct spi_nor *nor)
 548 {
 549         int ret = spi_nor_read_sr(nor, nor->bouncebuf);
 550
 551         if (ret)
 552                 return ret;
 553
 554         if (nor->flags & SNOR_F_USE_CLSR &&
 555             nor->bouncebuf[0] & (SR_E_ERR | SR_P_ERR)) {
 556                 if (nor->bouncebuf[0] & SR_E_ERR)
 557                         dev_err(nor->dev, "Erase Error occurred\n");
 558                 else
 559                         dev_err(nor->dev, "Programming Error occurred\n");
 560
 561                 spi_nor_clear_sr(nor);
 562
 563                 /*
 564                  * WEL bit remains set to one when an erase or page program
 565                  * error occurs. Issue a Write Disable command to protect
 566                  * against inadvertent writes that can possibly corrupt the
 567                  * contents of the memory.
 568                  */
 569                 ret = spi_nor_write_disable(nor);
 570                 if (ret)
 571                         return ret;
 572
 573                 return -EIO;
 574         }
 575
 576         return !(nor->bouncebuf[0] & SR_WIP);
 577 }
 578
 579 /**
 580  * spi_nor_clear_fsr() - Clear the Flag Status Register.
 581  * @nor:        pointer to 'struct spi_nor'.
 582  */
 583 static void spi_nor_clear_fsr(struct spi_nor *nor)
 584 {
 585         int ret;
 586
 587         if (nor->spimem) {
 588                 struct spi_mem_op op =
 589                         SPI_MEM_OP(SPI_MEM_OP_CMD(SPINOR_OP_CLFSR, 1),
 590                                    SPI_MEM_OP_NO_ADDR,
 591                                    SPI_MEM_OP_NO_DUMMY,
 592                                    SPI_MEM_OP_NO_DATA);
 593
 594                 ret = spi_mem_exec_op(nor->spimem, &op);
 595         } else {
 596                 ret = nor->controller_ops->write_reg(nor, SPINOR_OP_CLFSR,
 597                                                      NULL, 0);
 598         }
 599
 600         if (ret)
 601                 dev_dbg(nor->dev, "error %d clearing FSR\n", ret);
 602 }
 603
 604 /**
 605  * spi_nor_fsr_ready() - Query the Flag Status Register to see if the flash is
 606  * ready for new commands.
 607  * @nor:        pointer to 'struct spi_nor'.
 608  *
 609  * Return: 1 if ready, 0 if not ready, -errno on errors.
 610  */
 611 static int spi_nor_fsr_ready(struct spi_nor *nor)
 612 {
 613         int ret = spi_nor_read_fsr(nor, nor->bouncebuf);
 614
 615         if (ret)
 616                 return ret;
 617
 618         if (nor->bouncebuf[0] & (FSR_E_ERR | FSR_P_ERR)) {
 619                 if (nor->bouncebuf[0] & FSR_E_ERR)
 620                         dev_err(nor->dev, "Erase operation failed.\n");
 621                 else
 622                         dev_err(nor->dev, "Program operation failed.\n");
 623
 624                 if (nor->bouncebuf[0] & FSR_PT_ERR)
 625                         dev_err(nor->dev,
 626                         "Attempted to modify a protected sector.\n");
 627
 628                 spi_nor_clear_fsr(nor);
 629
 630                 /*
 631                  * WEL bit remains set to one when an erase or page program
 632                  * error occurs. Issue a Write Disable command to protect
 633                  * against inadvertent writes that can possibly corrupt the
 634                  * contents of the memory.
 635                  */
 636                 ret = spi_nor_write_disable(nor);
 637                 if (ret)
 638                         return ret;
 639
 640                 return -EIO;
 641         }
 642
 643         return !!(nor->bouncebuf[0] & FSR_READY);
 644 }
 645
 646 /**
 647  * spi_nor_ready() - Query the flash to see if it is ready for new commands.
 648  * @nor:        pointer to 'struct spi_nor'.
 649  *
 650  * Return: 1 if ready, 0 if not ready, -errno on errors.
 651  */
 652 static int spi_nor_ready(struct spi_nor *nor)
 653 {
 654         int sr, fsr;
 655
 656         if (nor->flags & SNOR_F_READY_XSR_RDY)
 657                 sr = spi_nor_xsr_ready(nor);
 658         else
 659                 sr = spi_nor_sr_ready(nor);
 660         if (sr < 0)
 661                 return sr;
 662         fsr = nor->flags & SNOR_F_USE_FSR ? spi_nor_fsr_ready(nor) : 1;
 663         if (fsr < 0)
 664                 return fsr;
 665         return sr && fsr;
 666 }
 667
 668 /**
 669  * spi_nor_wait_till_ready_with_timeout() - Service routine to read the
 670  * Status Register until ready, or timeout occurs.
 671  * @nor:                pointer to "struct spi_nor".
 672  * @timeout_jiffies:    jiffies to wait until timeout.
 673  *
 674  * Return: 0 on success, -errno otherwise.
 675  */
 676 static int spi_nor_wait_till_ready_with_timeout(struct spi_nor *nor,
 677                                                 unsigned long timeout_jiffies)
 678 {
 679         unsigned long deadline;
 680         int timeout = 0, ret;
 681
 682         deadline = jiffies + timeout_jiffies;
 683
 684         while (!timeout) {
 685                 if (time_after_eq(jiffies, deadline))
 686                         timeout = 1;
 687
 688                 ret = spi_nor_ready(nor);
 689                 if (ret < 0)
 690                         return ret;
 691                 if (ret)
 692                         return 0;
 693
 694                 cond_resched();
 695         }
 696
 697         dev_dbg(nor->dev, "flash operation timed out\n");
 698
 699         return -ETIMEDOUT;
 700 }
 701
 702 /**
 703  * spi_nor_wait_till_ready() - Wait for a predefined amount of time for the
 704  * flash to be ready, or timeout occurs.
 705  * @nor:        pointer to "struct spi_nor".
 706  *
 707  * Return: 0 on success, -errno otherwise.
 708  */
 709 int spi_nor_wait_till_ready(struct spi_nor *nor)
 710 {
 711         return spi_nor_wait_till_ready_with_timeout(nor,
 712                                                     DEFAULT_READY_WAIT_JIFFIES);
 713 }
 714
 715 /**
 716  * spi_nor_write_sr() - Write the Status Register.
 717  * @nor:        pointer to 'struct spi_nor'.
 718  * @sr:         pointer to DMA-able buffer to write to the Status Register.
 719  * @len:        number of bytes to write to the Status Register.
 720  *
 721  * Return: 0 on success, -errno otherwise.
 722  */
 723 static int spi_nor_write_sr(struct spi_nor *nor, const u8 *sr, size_t len)
 724 {
 725         int ret;
 726
 727         ret = spi_nor_write_enable(nor);
 728         if (ret)
 729                 return ret;
 730
 731         if (nor->spimem) {
 732                 struct spi_mem_op op =
 733                         SPI_MEM_OP(SPI_MEM_OP_CMD(SPINOR_OP_WRSR, 1),
 734                                    SPI_MEM_OP_NO_ADDR,
 735                                    SPI_MEM_OP_NO_DUMMY,
 736                                    SPI_MEM_OP_DATA_OUT(len, sr, 1));
 737
 738                 ret = spi_mem_exec_op(nor->spimem, &op);
 739         } else {
 740                 ret = nor->controller_ops->write_reg(nor, SPINOR_OP_WRSR,
 741                                                      sr, len);
 742         }
 743
 744         if (ret) {
 745                 dev_dbg(nor->dev, "error %d writing SR\n", ret);
 746                 return ret;
 747         }
 748
 749         return spi_nor_wait_till_ready(nor);
 750 }
 751
 752 /**
 753  * spi_nor_write_sr1_and_check() - Write one byte to the Status Register 1 and
 754  * ensure that the byte written match the received value.
 755  * @nor:        pointer to a 'struct spi_nor'.
 756  * @sr1:        byte value to be written to the Status Register.
 757  *
 758  * Return: 0 on success, -errno otherwise.
 759  */
 760 static int spi_nor_write_sr1_and_check(struct spi_nor *nor, u8 sr1)
 761 {
 762         int ret;
 763
 764         nor->bouncebuf[0] = sr1;
 765
 766         ret = spi_nor_write_sr(nor, nor->bouncebuf, 1);
 767         if (ret)
 768                 return ret;
 769
 770         ret = spi_nor_read_sr(nor, nor->bouncebuf);
 771         if (ret)
 772                 return ret;
 773
 774         if (nor->bouncebuf[0] != sr1) {
 775                 dev_dbg(nor->dev, "SR1: read back test failed\n");
 776                 return -EIO;
 777         }
 778
 779         return 0;
 780 }
 781
 782 /**
 783  * spi_nor_write_16bit_sr_and_check() - Write the Status Register 1 and the
 784  * Status Register 2 in one shot. Ensure that the byte written in the Status
 785  * Register 1 match the received value, and that the 16-bit Write did not
 786  * affect what was already in the Status Register 2.
 787  * @nor:        pointer to a 'struct spi_nor'.
 788  * @sr1:        byte value to be written to the Status Register 1.
 789  *
 790  * Return: 0 on success, -errno otherwise.
 791  */
 792 static int spi_nor_write_16bit_sr_and_check(struct spi_nor *nor, u8 sr1)
 793 {
 794         int ret;
 795         u8 *sr_cr = nor->bouncebuf;
 796         u8 cr_written;
 797
 798         /* Make sure we don't overwrite the contents of Status Register 2. */
 799         if (!(nor->flags & SNOR_F_NO_READ_CR)) {
 800                 ret = spi_nor_read_cr(nor, &sr_cr[1]);
 801                 if (ret)
 802                         return ret;
 803         } else if (nor->params->quad_enable) {
 804                 /*
 805                  * If the Status Register 2 Read command (35h) is not
 806                  * supported, we should at least be sure we don't
 807                  * change the value of the SR2 Quad Enable bit.
 808                  *
 809                  * We can safely assume that when the Quad Enable method is
 810                  * set, the value of the QE bit is one, as a consequence of the
 811                  * nor->params->quad_enable() call.
 812                  *
 813                  * We can safely assume that the Quad Enable bit is present in
 814                  * the Status Register 2 at BIT(1). According to the JESD216
 815                  * revB standard, BFPT DWORDS[15], bits 22:20, the 16-bit
 816                  * Write Status (01h) command is available just for the cases
 817                  * in which the QE bit is described in SR2 at BIT(1).
 818                  */
 819                 sr_cr[1] = SR2_QUAD_EN_BIT1;
 820         } else {
 821                 sr_cr[1] = 0;
 822         }
 823
 824         sr_cr[0] = sr1;
 825
 826         ret = spi_nor_write_sr(nor, sr_cr, 2);
 827         if (ret)
 828                 return ret;
 829
 830         if (nor->flags & SNOR_F_NO_READ_CR)
 831                 return 0;
 832
 833         cr_written = sr_cr[1];
 834
 835         ret = spi_nor_read_cr(nor, &sr_cr[1]);
 836         if (ret)
 837                 return ret;
 838
 839         if (cr_written != sr_cr[1]) {
 840                 dev_dbg(nor->dev, "CR: read back test failed\n");
 841                 return -EIO;
 842         }
 843
 844         return 0;
 845 }
 846
 847 /**
 848  * spi_nor_write_16bit_cr_and_check() - Write the Status Register 1 and the
 849  * Configuration Register in one shot. Ensure that the byte written in the
 850  * Configuration Register match the received value, and that the 16-bit Write
 851  * did not affect what was already in the Status Register 1.
 852  * @nor:        pointer to a 'struct spi_nor'.
 853  * @cr:         byte value to be written to the Configuration Register.
 854  *
 855  * Return: 0 on success, -errno otherwise.
 856  */
 857 static int spi_nor_write_16bit_cr_and_check(struct spi_nor *nor, u8 cr)
 858 {
 859         int ret;
 860         u8 *sr_cr = nor->bouncebuf;
 861         u8 sr_written;
 862
 863         /* Keep the current value of the Status Register 1. */
 864         ret = spi_nor_read_sr(nor, sr_cr);
 865         if (ret)
 866                 return ret;
 867
 868         sr_cr[1] = cr;
 869
 870         ret = spi_nor_write_sr(nor, sr_cr, 2);
 871         if (ret)
 872                 return ret;
 873
 874         sr_written = sr_cr[0];
 875
 876         ret = spi_nor_read_sr(nor, sr_cr);
 877         if (ret)
 878                 return ret;
 879
 880         if (sr_written != sr_cr[0]) {
 881                 dev_dbg(nor->dev, "SR: Read back test failed\n");
 882                 return -EIO;
 883         }
 884
 885         if (nor->flags & SNOR_F_NO_READ_CR)
 886                 return 0;
 887
 888         ret = spi_nor_read_cr(nor, &sr_cr[1]);
 889         if (ret)
 890                 return ret;
 891
 892         if (cr != sr_cr[1]) {
 893                 dev_dbg(nor->dev, "CR: read back test failed\n");
 894                 return -EIO;
 895         }
 896
 897         return 0;
 898 }
 899
 900 /**
 901  * spi_nor_write_sr_and_check() - Write the Status Register 1 and ensure that
 902  * the byte written match the received value without affecting other bits in the
 903  * Status Register 1 and 2.
 904  * @nor:        pointer to a 'struct spi_nor'.
 905  * @sr1:        byte value to be written to the Status Register.
 906  *
 907  * Return: 0 on success, -errno otherwise.
 908  */
 909 int spi_nor_write_sr_and_check(struct spi_nor *nor, u8 sr1)
 910 {
 911         if (nor->flags & SNOR_F_HAS_16BIT_SR)
 912                 return spi_nor_write_16bit_sr_and_check(nor, sr1);
 913
 914         return spi_nor_write_sr1_and_check(nor, sr1);
 915 }
 916
 917 /**
 918  * spi_nor_write_sr2() - Write the Status Register 2 using the
 919  * SPINOR_OP_WRSR2 (3eh) command.
 920  * @nor:        pointer to 'struct spi_nor'.
 921  * @sr2:        pointer to DMA-able buffer to write to the Status Register 2.
 922  *
 923  * Return: 0 on success, -errno otherwise.
 924  */
 925 static int spi_nor_write_sr2(struct spi_nor *nor, const u8 *sr2)
 926 {
 927         int ret;
 928
 929         ret = spi_nor_write_enable(nor);
 930         if (ret)
 931                 return ret;
 932
 933         if (nor->spimem) {
 934                 struct spi_mem_op op =
 935                         SPI_MEM_OP(SPI_MEM_OP_CMD(SPINOR_OP_WRSR2, 1),
 936                                    SPI_MEM_OP_NO_ADDR,
 937                                    SPI_MEM_OP_NO_DUMMY,
 938                                    SPI_MEM_OP_DATA_OUT(1, sr2, 1));
 939
 940                 ret = spi_mem_exec_op(nor->spimem, &op);
 941         } else {
 942                 ret = nor->controller_ops->write_reg(nor, SPINOR_OP_WRSR2,
 943                                                      sr2, 1);
 944         }
 945
 946         if (ret) {
 947                 dev_dbg(nor->dev, "error %d writing SR2\n", ret);
 948                 return ret;
 949         }
 950
 951         return spi_nor_wait_till_ready(nor);
 952 }
 953
 954 /**
 955  * spi_nor_read_sr2() - Read the Status Register 2 using the
 956  * SPINOR_OP_RDSR2 (3fh) command.
 957  * @nor:        pointer to 'struct spi_nor'.
 958  * @sr2:        pointer to DMA-able buffer where the value of the
 959  *              Status Register 2 will be written.
 960  *
 961  * Return: 0 on success, -errno otherwise.
 962  */
 963 static int spi_nor_read_sr2(struct spi_nor *nor, u8 *sr2)
 964 {
 965         int ret;
 966
 967         if (nor->spimem) {
 968                 struct spi_mem_op op =
 969                         SPI_MEM_OP(SPI_MEM_OP_CMD(SPINOR_OP_RDSR2, 1),
 970                                    SPI_MEM_OP_NO_ADDR,
 971                                    SPI_MEM_OP_NO_DUMMY,
 972                                    SPI_MEM_OP_DATA_IN(1, sr2, 1));
 973
 974                 ret = spi_mem_exec_op(nor->spimem, &op);
 975         } else {
 976                 ret = nor->controller_ops->read_reg(nor, SPINOR_OP_RDSR2,
 977                                                     sr2, 1);
 978         }
 979
 980         if (ret)
 981                 dev_dbg(nor->dev, "error %d reading SR2\n", ret);
 982
 983         return ret;
 984 }
 985
 986 /**
 987  * spi_nor_erase_chip() - Erase the entire flash memory.
 988  * @nor:        pointer to 'struct spi_nor'.
 989  *
 990  * Return: 0 on success, -errno otherwise.
 991  */
 992 static int spi_nor_erase_chip(struct spi_nor *nor)
 993 {
 994         int ret;
 995
 996         dev_dbg(nor->dev, " %lldKiB\n", (long long)(nor->mtd.size >> 10));
 997
 998         if (nor->spimem) {
 999                 struct spi_mem_op op =
1000                         SPI_MEM_OP(SPI_MEM_OP_CMD(SPINOR_OP_CHIP_ERASE, 1),
1001                                    SPI_MEM_OP_NO_ADDR,
1002                                    SPI_MEM_OP_NO_DUMMY,
1003                                    SPI_MEM_OP_NO_DATA);
1004
1005                 ret = spi_mem_exec_op(nor->spimem, &op);
1006         } else {
1007                 ret = nor->controller_ops->write_reg(nor, SPINOR_OP_CHIP_ERASE,
1008                                                      NULL, 0);
1009         }
1010
1011         if (ret)
1012                 dev_dbg(nor->dev, "error %d erasing chip\n", ret);
1013
1014         return ret;
1015 }
1016
1017 static u8 spi_nor_convert_opcode(u8 opcode, const u8 table[][2], size_t size)
1018 {
1019         size_t i;
1020
1021         for (i = 0; i < size; i++)
1022                 if (table[i][0] == opcode)
1023                         return table[i][1];
1024
1025         /* No conversion found, keep input op code. */
1026         return opcode;
1027 }
1028
1029 u8 spi_nor_convert_3to4_read(u8 opcode)
1030 {
1031         static const u8 spi_nor_3to4_read[][2] = {
1032                 { SPINOR_OP_READ,       SPINOR_OP_READ_4B },
1033                 { SPINOR_OP_READ_FAST,  SPINOR_OP_READ_FAST_4B },
1034                 { SPINOR_OP_READ_1_1_2, SPINOR_OP_READ_1_1_2_4B },
1035                 { SPINOR_OP_READ_1_2_2, SPINOR_OP_READ_1_2_2_4B },
1036                 { SPINOR_OP_READ_1_1_4, SPINOR_OP_READ_1_1_4_4B },
1037                 { SPINOR_OP_READ_1_4_4, SPINOR_OP_READ_1_4_4_4B },
1038                 { SPINOR_OP_READ_1_1_8, SPINOR_OP_READ_1_1_8_4B },
1039                 { SPINOR_OP_READ_1_8_8, SPINOR_OP_READ_1_8_8_4B },
1040
1041                 { SPINOR_OP_READ_1_1_1_DTR,     SPINOR_OP_READ_1_1_1_DTR_4B },
1042                 { SPINOR_OP_READ_1_2_2_DTR,     SPINOR_OP_READ_1_2_2_DTR_4B },
1043                 { SPINOR_OP_READ_1_4_4_DTR,     SPINOR_OP_READ_1_4_4_DTR_4B },
1044         };
1045
1046         return spi_nor_convert_opcode(opcode, spi_nor_3to4_read,
1047                                       ARRAY_SIZE(spi_nor_3to4_read));
1048 }
1049
1050 static u8 spi_nor_convert_3to4_program(u8 opcode)
1051 {
1052         static const u8 spi_nor_3to4_program[][2] = {
1053                 { SPINOR_OP_PP,         SPINOR_OP_PP_4B },
1054                 { SPINOR_OP_PP_1_1_4,   SPINOR_OP_PP_1_1_4_4B },
1055                 { SPINOR_OP_PP_1_4_4,   SPINOR_OP_PP_1_4_4_4B },
1056                 { SPINOR_OP_PP_1_1_8,   SPINOR_OP_PP_1_1_8_4B },
1057                 { SPINOR_OP_PP_1_8_8,   SPINOR_OP_PP_1_8_8_4B },
1058         };
1059
1060         return spi_nor_convert_opcode(opcode, spi_nor_3to4_program,
1061                                       ARRAY_SIZE(spi_nor_3to4_program));
1062 }
1063
1064 static u8 spi_nor_convert_3to4_erase(u8 opcode)
1065 {
1066         static const u8 spi_nor_3to4_erase[][2] = {
1067                 { SPINOR_OP_BE_4K,      SPINOR_OP_BE_4K_4B },
1068                 { SPINOR_OP_BE_32K,     SPINOR_OP_BE_32K_4B },
1069                 { SPINOR_OP_SE,         SPINOR_OP_SE_4B },
1070         };
1071
1072         return spi_nor_convert_opcode(opcode, spi_nor_3to4_erase,
1073                                       ARRAY_SIZE(spi_nor_3to4_erase));
1074 }
1075
1076 static bool spi_nor_has_uniform_erase(const struct spi_nor *nor)
1077 {
1078         return !!nor->params->erase_map.uniform_erase_type;
1079 }
1080
1081 static void spi_nor_set_4byte_opcodes(struct spi_nor *nor)
1082 {
1083         nor->read_opcode = spi_nor_convert_3to4_read(nor->read_opcode);
1084         nor->program_opcode = spi_nor_convert_3to4_program(nor->program_opcode);
1085         nor->erase_opcode = spi_nor_convert_3to4_erase(nor->erase_opcode);
1086
1087         if (!spi_nor_has_uniform_erase(nor)) {
1088                 struct spi_nor_erase_map *map = &nor->params->erase_map;
1089                 struct spi_nor_erase_type *erase;
1090                 int i;
1091
1092                 for (i = 0; i < SNOR_ERASE_TYPE_MAX; i++) {
1093                         erase = &map->erase_type[i];
1094                         erase->opcode =
1095                                 spi_nor_convert_3to4_erase(erase->opcode);
1096                 }
1097         }
1098 }
1099
1100 int spi_nor_lock_and_prep(struct spi_nor *nor)
1101 {
1102         int ret = 0;
1103
1104         mutex_lock(&nor->lock);
1105
1106         if (nor->controller_ops &&  nor->controller_ops->prepare) {
1107                 ret = nor->controller_ops->prepare(nor);
1108                 if (ret) {
1109                         mutex_unlock(&nor->lock);
1110                         return ret;
1111                 }
1112         }
1113         return ret;
1114 }
1115
1116 void spi_nor_unlock_and_unprep(struct spi_nor *nor)
1117 {
1118         if (nor->controller_ops && nor->controller_ops->unprepare)
1119                 nor->controller_ops->unprepare(nor);
1120         mutex_unlock(&nor->lock);
1121 }
1122
1123 static u32 spi_nor_convert_addr(struct spi_nor *nor, loff_t addr)
1124 {
1125         if (!nor->params->convert_addr)
1126                 return addr;
1127
1128         return nor->params->convert_addr(nor, addr);
1129 }
1130
1131 /*
1132  * Initiate the erasure of a single sector
1133  */
1134 static int spi_nor_erase_sector(struct spi_nor *nor, u32 addr)
1135 {
1136         int i;
1137
1138         addr = spi_nor_convert_addr(nor, addr);
1139
1140         if (nor->spimem) {
1141                 struct spi_mem_op op =
1142                         SPI_MEM_OP(SPI_MEM_OP_CMD(nor->erase_opcode, 1),
1143                                    SPI_MEM_OP_ADDR(nor->addr_width, addr, 1),
1144                                    SPI_MEM_OP_NO_DUMMY,
1145                                    SPI_MEM_OP_NO_DATA);
1146
1147                 return spi_mem_exec_op(nor->spimem, &op);
1148         } else if (nor->controller_ops->erase) {
1149                 return nor->controller_ops->erase(nor, addr);
1150         }
1151
1152         /*
1153          * Default implementation, if driver doesn't have a specialized HW
1154          * control
1155          */
1156         for (i = nor->addr_width - 1; i >= 0; i--) {
1157                 nor->bouncebuf[i] = addr & 0xff;
1158                 addr >>= 8;
1159         }
1160
1161         return nor->controller_ops->write_reg(nor, nor->erase_opcode,
1162                                               nor->bouncebuf, nor->addr_width);
1163 }
1164
1165 /**
1166  * spi_nor_div_by_erase_size() - calculate remainder and update new dividend
1167  * @erase:      pointer to a structure that describes a SPI NOR erase type
1168  * @dividend:   dividend value
1169  * @remainder:  pointer to u32 remainder (will be updated)
1170  *
1171  * Return: the result of the division
1172  */
1173 static u64 spi_nor_div_by_erase_size(const struct spi_nor_erase_type *erase,
1174                                      u64 dividend, u32 *remainder)
1175 {
1176         /* JEDEC JESD216B Standard imposes erase sizes to be power of 2. */
1177         *remainder = (u32)dividend & erase->size_mask;
1178         return dividend >> erase->size_shift;
1179 }
1180
1181 /**
1182  * spi_nor_find_best_erase_type() - find the best erase type for the given
1183  *                                  offset in the serial flash memory and the
1184  *                                  number of bytes to erase. The region in
1185  *                                  which the address fits is expected to be
1186  *                                  provided.
1187  * @map:        the erase map of the SPI NOR
1188  * @region:     pointer to a structure that describes a SPI NOR erase region
1189  * @addr:       offset in the serial flash memory
1190  * @len:        number of bytes to erase
1191  *
1192  * Return: a pointer to the best fitted erase type, NULL otherwise.
1193  */
1194 static const struct spi_nor_erase_type *
1195 spi_nor_find_best_erase_type(const struct spi_nor_erase_map *map,
1196                              const struct spi_nor_erase_region *region,
1197                              u64 addr, u32 len)
1198 {
1199         const struct spi_nor_erase_type *erase;
1200         u32 rem;
1201         int i;
1202         u8 erase_mask = region->offset & SNOR_ERASE_TYPE_MASK;
1203
1204         /*
1205          * Erase types are ordered by size, with the smallest erase type at
1206          * index 0.
1207          */
1208         for (i = SNOR_ERASE_TYPE_MAX - 1; i >= 0; i--) {
1209                 /* Does the erase region support the tested erase type? */
1210                 if (!(erase_mask & BIT(i)))
1211                         continue;
1212
1213                 erase = &map->erase_type[i];
1214
1215                 /* Alignment is not mandatory for overlaid regions */
1216                 if (region->offset & SNOR_OVERLAID_REGION &&
1217                     region->size <= len)
1218                         return erase;
1219
1220                 /* Don't erase more than what the user has asked for. */
1221                 if (erase->size > len)
1222                         continue;
1223
1224                 spi_nor_div_by_erase_size(erase, addr, &rem);
1225                 if (rem)
1226                         continue;
1227                 else
1228                         return erase;
1229         }
1230
1231         return NULL;
1232 }
1233
1234 static u64 spi_nor_region_is_last(const struct spi_nor_erase_region *region)
1235 {
1236         return region->offset & SNOR_LAST_REGION;
1237 }
1238
1239 static u64 spi_nor_region_end(const struct spi_nor_erase_region *region)
1240 {
1241         return (region->offset & ~SNOR_ERASE_FLAGS_MASK) + region->size;
1242 }
1243
1244 /**
1245  * spi_nor_region_next() - get the next spi nor region
1246  * @region:     pointer to a structure that describes a SPI NOR erase region
1247  *
1248  * Return: the next spi nor region or NULL if last region.
1249  */
1250 struct spi_nor_erase_region *
1251 spi_nor_region_next(struct spi_nor_erase_region *region)
1252 {
1253         if (spi_nor_region_is_last(region))
1254                 return NULL;
1255         region++;
1256         return region;
1257 }
1258
1259 /**
1260  * spi_nor_find_erase_region() - find the region of the serial flash memory in
1261  *                               which the offset fits
1262  * @map:        the erase map of the SPI NOR
1263  * @addr:       offset in the serial flash memory
1264  *
1265  * Return: a pointer to the spi_nor_erase_region struct, ERR_PTR(-errno)
1266  *         otherwise.
1267  */
1268 static struct spi_nor_erase_region *
1269 spi_nor_find_erase_region(const struct spi_nor_erase_map *map, u64 addr)
1270 {
1271         struct spi_nor_erase_region *region = map->regions;
1272         u64 region_start = region->offset & ~SNOR_ERASE_FLAGS_MASK;
1273         u64 region_end = region_start + region->size;
1274
1275         while (addr < region_start || addr >= region_end) {
1276                 region = spi_nor_region_next(region);
1277                 if (!region)
1278                         return ERR_PTR(-EINVAL);
1279
1280                 region_start = region->offset & ~SNOR_ERASE_FLAGS_MASK;
1281                 region_end = region_start + region->size;
1282         }
1283
1284         return region;
1285 }
1286
1287 /**
1288  * spi_nor_init_erase_cmd() - initialize an erase command
1289  * @region:     pointer to a structure that describes a SPI NOR erase region
1290  * @erase:      pointer to a structure that describes a SPI NOR erase type
1291  *
1292  * Return: the pointer to the allocated erase command, ERR_PTR(-errno)
1293  *         otherwise.
1294  */
1295 static struct spi_nor_erase_command *
1296 spi_nor_init_erase_cmd(const struct spi_nor_erase_region *region,
1297                        const struct spi_nor_erase_type *erase)
1298 {
1299         struct spi_nor_erase_command *cmd;
1300
1301         cmd = kmalloc(sizeof(*cmd), GFP_KERNEL);
1302         if (!cmd)
1303                 return ERR_PTR(-ENOMEM);
1304
1305         INIT_LIST_HEAD(&cmd->list);
1306         cmd->opcode = erase->opcode;
1307         cmd->count = 1;
1308
1309         if (region->offset & SNOR_OVERLAID_REGION)
1310                 cmd->size = region->size;
1311         else
1312                 cmd->size = erase->size;
1313
1314         return cmd;
1315 }
1316
1317 /**
1318  * spi_nor_destroy_erase_cmd_list() - destroy erase command list
1319  * @erase_list: list of erase commands
1320  */
1321 static void spi_nor_destroy_erase_cmd_list(struct list_head *erase_list)
1322 {
1323         struct spi_nor_erase_command *cmd, *next;
1324
1325         list_for_each_entry_safe(cmd, next, erase_list, list) {
1326                 list_del(&cmd->list);
1327                 kfree(cmd);
1328         }
1329 }
1330
1331 /**
1332  * spi_nor_init_erase_cmd_list() - initialize erase command list
1333  * @nor:        pointer to a 'struct spi_nor'
1334  * @erase_list: list of erase commands to be executed once we validate that the
1335  *              erase can be performed
1336  * @addr:       offset in the serial flash memory
1337  * @len:        number of bytes to erase
1338  *
1339  * Builds the list of best fitted erase commands and verifies if the erase can
1340  * be performed.
1341  *
1342  * Return: 0 on success, -errno otherwise.
1343  */
1344 static int spi_nor_init_erase_cmd_list(struct spi_nor *nor,
1345                                        struct list_head *erase_list,
1346                                        u64 addr, u32 len)
1347 {
1348         const struct spi_nor_erase_map *map = &nor->params->erase_map;
1349         const struct spi_nor_erase_type *erase, *prev_erase = NULL;
1350         struct spi_nor_erase_region *region;
1351         struct spi_nor_erase_command *cmd = NULL;
1352         u64 region_end;
1353         int ret = -EINVAL;
1354
1355         region = spi_nor_find_erase_region(map, addr);
1356         if (IS_ERR(region))
1357                 return PTR_ERR(region);
1358
1359         region_end = spi_nor_region_end(region);
1360
1361         while (len) {
1362                 erase = spi_nor_find_best_erase_type(map, region, addr, len);
1363                 if (!erase)
1364                         goto destroy_erase_cmd_list;
1365
1366                 if (prev_erase != erase ||
1367                     region->offset & SNOR_OVERLAID_REGION) {
1368                         cmd = spi_nor_init_erase_cmd(region, erase);
1369                         if (IS_ERR(cmd)) {
1370                                 ret = PTR_ERR(cmd);
1371                                 goto destroy_erase_cmd_list;
1372                         }
1373
1374                         list_add_tail(&cmd->list, erase_list);
1375                 } else {
1376                         cmd->count++;
1377                 }
1378
1379                 addr += cmd->size;
1380                 len -= cmd->size;
1381
1382                 if (len && addr >= region_end) {
1383                         region = spi_nor_region_next(region);
1384                         if (!region)
1385                                 goto destroy_erase_cmd_list;
1386                         region_end = spi_nor_region_end(region);
1387                 }
1388
1389                 prev_erase = erase;
1390         }
1391
1392         return 0;
1393
1394 destroy_erase_cmd_list:
1395         spi_nor_destroy_erase_cmd_list(erase_list);
1396         return ret;
1397 }
1398
1399 /**
1400  * spi_nor_erase_multi_sectors() - perform a non-uniform erase
1401  * @nor:        pointer to a 'struct spi_nor'
1402  * @addr:       offset in the serial flash memory
1403  * @len:        number of bytes to erase
1404  *
1405  * Build a list of best fitted erase commands and execute it once we validate
1406  * that the erase can be performed.
1407  *
1408  * Return: 0 on success, -errno otherwise.
1409  */
1410 static int spi_nor_erase_multi_sectors(struct spi_nor *nor, u64 addr, u32 len)
1411 {
1412         LIST_HEAD(erase_list);
1413         struct spi_nor_erase_command *cmd, *next;
1414         int ret;
1415
1416         ret = spi_nor_init_erase_cmd_list(nor, &erase_list, addr, len);
1417         if (ret)
1418                 return ret;
1419
1420         list_for_each_entry_safe(cmd, next, &erase_list, list) {
1421                 nor->erase_opcode = cmd->opcode;
1422                 while (cmd->count) {
1423                         ret = spi_nor_write_enable(nor);
1424                         if (ret)
1425                                 goto destroy_erase_cmd_list;
1426
1427                         ret = spi_nor_erase_sector(nor, addr);
1428                         if (ret)
1429                                 goto destroy_erase_cmd_list;
1430
1431                         addr += cmd->size;
1432                         cmd->count--;
1433
1434                         ret = spi_nor_wait_till_ready(nor);
1435                         if (ret)
1436                                 goto destroy_erase_cmd_list;
1437                 }
1438                 list_del(&cmd->list);
1439                 kfree(cmd);
1440         }
1441
1442         return 0;
1443
1444 destroy_erase_cmd_list:
1445         spi_nor_destroy_erase_cmd_list(&erase_list);
1446         return ret;
1447 }
1448
1449 /*
1450  * Erase an address range on the nor chip.  The address range may extend
1451  * one or more erase sectors.  Return an error is there is a problem erasing.
1452  */
1453 static int spi_nor_erase(struct mtd_info *mtd, struct erase_info *instr)
1454 {
1455         struct spi_nor *nor = mtd_to_spi_nor(mtd);
1456         u32 addr, len;
1457         uint32_t rem;
1458         int ret;
1459
1460         dev_dbg(nor->dev, "at 0x%llx, len %lld\n", (long long)instr->addr,
1461                         (long long)instr->len);
1462
1463         if (spi_nor_has_uniform_erase(nor)) {
1464                 div_u64_rem(instr->len, mtd->erasesize, &rem);
1465                 if (rem)
1466                         return -EINVAL;
1467         }
1468
1469         addr = instr->addr;
1470         len = instr->len;
1471
1472         ret = spi_nor_lock_and_prep(nor);
1473         if (ret)
1474                 return ret;
1475
1476         /* whole-chip erase? */
1477         if (len == mtd->size && !(nor->flags & SNOR_F_NO_OP_CHIP_ERASE)) {
1478                 unsigned long timeout;
1479
1480                 ret = spi_nor_write_enable(nor);
1481                 if (ret)
1482                         goto erase_err;
1483
1484                 ret = spi_nor_erase_chip(nor);
1485                 if (ret)
1486                         goto erase_err;
1487
1488                 /*
1489                  * Scale the timeout linearly with the size of the flash, with
1490                  * a minimum calibrated to an old 2MB flash. We could try to
1491                  * pull these from CFI/SFDP, but these values should be good
1492                  * enough for now.
1493                  */
1494                 timeout = max(CHIP_ERASE_2MB_READY_WAIT_JIFFIES,
1495                               CHIP_ERASE_2MB_READY_WAIT_JIFFIES *
1496                               (unsigned long)(mtd->size / SZ_2M));
1497                 ret = spi_nor_wait_till_ready_with_timeout(nor, timeout);
1498                 if (ret)
1499                         goto erase_err;
1500
1501         /* REVISIT in some cases we could speed up erasing large regions
1502          * by using SPINOR_OP_SE instead of SPINOR_OP_BE_4K.  We may have set up
1503          * to use "small sector erase", but that's not always optimal.
1504          */
1505
1506         /* "sector"-at-a-time erase */
1507         } else if (spi_nor_has_uniform_erase(nor)) {
1508                 while (len) {
1509                         ret = spi_nor_write_enable(nor);
1510                         if (ret)
1511                                 goto erase_err;
1512
1513                         ret = spi_nor_erase_sector(nor, addr);
1514                         if (ret)
1515                                 goto erase_err;
1516
1517                         addr += mtd->erasesize;
1518                         len -= mtd->erasesize;
1519
1520                         ret = spi_nor_wait_till_ready(nor);
1521                         if (ret)
1522                                 goto erase_err;
1523                 }
1524
1525         /* erase multiple sectors */
1526         } else {
1527                 ret = spi_nor_erase_multi_sectors(nor, addr, len);
1528                 if (ret)
1529                         goto erase_err;
1530         }
1531
1532         ret = spi_nor_write_disable(nor);
1533
1534 erase_err:
1535         spi_nor_unlock_and_unprep(nor);
1536
1537         return ret;
1538 }
1539
1540 static u8 spi_nor_get_sr_bp_mask(struct spi_nor *nor)
1541 {
1542         u8 mask = SR_BP2 | SR_BP1 | SR_BP0;
1543
1544         if (nor->flags & SNOR_F_HAS_SR_BP3_BIT6)
1545                 return mask | SR_BP3_BIT6;
1546
1547         if (nor->flags & SNOR_F_HAS_4BIT_BP)
1548                 return mask | SR_BP3;
1549
1550         return mask;
1551 }
1552
1553 static u8 spi_nor_get_sr_tb_mask(struct spi_nor *nor)
1554 {
1555         if (nor->flags & SNOR_F_HAS_SR_TB_BIT6)
1556                 return SR_TB_BIT6;
1557         else
1558                 return SR_TB_BIT5;
1559 }
1560
1561 static u64 spi_nor_get_min_prot_length_sr(struct spi_nor *nor)
1562 {
1563         unsigned int bp_slots, bp_slots_needed;
1564         u8 mask = spi_nor_get_sr_bp_mask(nor);
1565
1566         /* Reserved one for "protect none" and one for "protect all". */
1567         bp_slots = (1 << hweight8(mask)) - 2;
1568         bp_slots_needed = ilog2(nor->info->n_sectors);
1569
1570         if (bp_slots_needed > bp_slots)
1571                 return nor->info->sector_size <<
1572                         (bp_slots_needed - bp_slots);
1573         else
1574                 return nor->info->sector_size;
1575 }
1576
1577 static void spi_nor_get_locked_range_sr(struct spi_nor *nor, u8 sr, loff_t *ofs,
1578                                         uint64_t *len)
1579 {
1580         struct mtd_info *mtd = &nor->mtd;
1581         u64 min_prot_len;
1582         u8 mask = spi_nor_get_sr_bp_mask(nor);
1583         u8 tb_mask = spi_nor_get_sr_tb_mask(nor);
1584         u8 bp, val = sr & mask;
1585
1586         if (nor->flags & SNOR_F_HAS_SR_BP3_BIT6 && val & SR_BP3_BIT6)
1587                 val = (val & ~SR_BP3_BIT6) | SR_BP3;
1588
1589         bp = val >> SR_BP_SHIFT;
1590
1591         if (!bp) {
1592                 /* No protection */
1593                 *ofs = 0;
1594                 *len = 0;
1595                 return;
1596         }
1597
1598         min_prot_len = spi_nor_get_min_prot_length_sr(nor);
1599         *len = min_prot_len << (bp - 1);
1600
1601         if (*len > mtd->size)
1602                 *len = mtd->size;
1603
1604         if (nor->flags & SNOR_F_HAS_SR_TB && sr & tb_mask)
1605                 *ofs = 0;
1606         else
1607                 *ofs = mtd->size - *len;
1608 }
1609
1610 /*
1611  * Return 1 if the entire region is locked (if @locked is true) or unlocked (if
1612  * @locked is false); 0 otherwise
1613  */
1614 static int spi_nor_check_lock_status_sr(struct spi_nor *nor, loff_t ofs,
1615                                         uint64_t len, u8 sr, bool locked)
1616 {
1617         loff_t lock_offs;
1618         uint64_t lock_len;
1619
1620         if (!len)
1621                 return 1;
1622
1623         spi_nor_get_locked_range_sr(nor, sr, &lock_offs, &lock_len);
1624
1625         if (locked)
1626                 /* Requested range is a sub-range of locked range */
1627                 return (ofs + len <= lock_offs + lock_len) && (ofs >= lock_offs);
1628         else
1629                 /* Requested range does not overlap with locked range */
1630                 return (ofs >= lock_offs + lock_len) || (ofs + len <= lock_offs);
1631 }
1632
1633 static int spi_nor_is_locked_sr(struct spi_nor *nor, loff_t ofs, uint64_t len,
1634                                 u8 sr)
1635 {
1636         return spi_nor_check_lock_status_sr(nor, ofs, len, sr, true);
1637 }
1638
1639 static int spi_nor_is_unlocked_sr(struct spi_nor *nor, loff_t ofs, uint64_t len,
1640                                   u8 sr)
1641 {
1642         return spi_nor_check_lock_status_sr(nor, ofs, len, sr, false);
1643 }
1644
1645 /*
1646  * Lock a region of the flash. Compatible with ST Micro and similar flash.
1647  * Supports the block protection bits BP{0,1,2}/BP{0,1,2,3} in the status
1648  * register
1649  * (SR). Does not support these features found in newer SR bitfields:
1650  *   - SEC: sector/block protect - only handle SEC=0 (block protect)
1651  *   - CMP: complement protect - only support CMP=0 (range is not complemented)
1652  *
1653  * Support for the following is provided conditionally for some flash:
1654  *   - TB: top/bottom protect
1655  *
1656  * Sample table portion for 8MB flash (Winbond w25q64fw):
1657  *
1658  *   SEC  |  TB   |  BP2  |  BP1  |  BP0  |  Prot Length  | Protected Portion
1659  *  --------------------------------------------------------------------------
1660  *    X   |   X   |   0   |   0   |   0   |  NONE         | NONE
1661  *    0   |   0   |   0   |   0   |   1   |  128 KB       | Upper 1/64
1662  *    0   |   0   |   0   |   1   |   0   |  256 KB       | Upper 1/32
1663  *    0   |   0   |   0   |   1   |   1   |  512 KB       | Upper 1/16
1664  *    0   |   0   |   1   |   0   |   0   |  1 MB         | Upper 1/8
1665  *    0   |   0   |   1   |   0   |   1   |  2 MB         | Upper 1/4
1666  *    0   |   0   |   1   |   1   |   0   |  4 MB         | Upper 1/2
1667  *    X   |   X   |   1   |   1   |   1   |  8 MB         | ALL
1668  *  ------|-------|-------|-------|-------|---------------|-------------------
1669  *    0   |   1   |   0   |   0   |   1   |  128 KB       | Lower 1/64
1670  *    0   |   1   |   0   |   1   |   0   |  256 KB       | Lower 1/32
1671  *    0   |   1   |   0   |   1   |   1   |  512 KB       | Lower 1/16
1672  *    0   |   1   |   1   |   0   |   0   |  1 MB         | Lower 1/8
1673  *    0   |   1   |   1   |   0   |   1   |  2 MB         | Lower 1/4
1674  *    0   |   1   |   1   |   1   |   0   |  4 MB         | Lower 1/2
1675  *
1676  * Returns negative on errors, 0 on success.
1677  */
1678 static int spi_nor_sr_lock(struct spi_nor *nor, loff_t ofs, uint64_t len)
1679 {
1680         struct mtd_info *mtd = &nor->mtd;
1681         u64 min_prot_len;
1682         int ret, status_old, status_new;
1683         u8 mask = spi_nor_get_sr_bp_mask(nor);
1684         u8 tb_mask = spi_nor_get_sr_tb_mask(nor);
1685         u8 pow, val;
1686         loff_t lock_len;
1687         bool can_be_top = true, can_be_bottom = nor->flags & SNOR_F_HAS_SR_TB;
1688         bool use_top;
1689
1690         ret = spi_nor_read_sr(nor, nor->bouncebuf);
1691         if (ret)
1692                 return ret;
1693
1694         status_old = nor->bouncebuf[0];
1695
1696         /* If nothing in our range is unlocked, we don't need to do anything */
1697         if (spi_nor_is_locked_sr(nor, ofs, len, status_old))
1698                 return 0;
1699
1700         /* If anything below us is unlocked, we can't use 'bottom' protection */
1701         if (!spi_nor_is_locked_sr(nor, 0, ofs, status_old))
1702                 can_be_bottom = false;
1703
1704         /* If anything above us is unlocked, we can't use 'top' protection */
1705         if (!spi_nor_is_locked_sr(nor, ofs + len, mtd->size - (ofs + len),
1706                                   status_old))
1707                 can_be_top = false;
1708
1709         if (!can_be_bottom && !can_be_top)
1710                 return -EINVAL;
1711
1712         /* Prefer top, if both are valid */
1713         use_top = can_be_top;
1714
1715         /* lock_len: length of region that should end up locked */
1716         if (use_top)
1717                 lock_len = mtd->size - ofs;
1718         else
1719                 lock_len = ofs + len;
1720
1721         if (lock_len == mtd->size) {
1722                 val = mask;
1723         } else {
1724                 min_prot_len = spi_nor_get_min_prot_length_sr(nor);
1725                 pow = ilog2(lock_len) - ilog2(min_prot_len) + 1;
1726                 val = pow << SR_BP_SHIFT;
1727
1728                 if (nor->flags & SNOR_F_HAS_SR_BP3_BIT6 && val & SR_BP3)
1729                         val = (val & ~SR_BP3) | SR_BP3_BIT6;
1730
1731                 if (val & ~mask)
1732                         return -EINVAL;
1733
1734                 /* Don't "lock" with no region! */
1735                 if (!(val & mask))
1736                         return -EINVAL;
1737         }
1738
1739         status_new = (status_old & ~mask & ~tb_mask) | val;
1740
1741         /* Disallow further writes if WP pin is asserted */
1742         status_new |= SR_SRWD;
1743
1744         if (!use_top)
1745                 status_new |= tb_mask;
1746
1747         /* Don't bother if they're the same */
1748         if (status_new == status_old)
1749                 return 0;
1750
1751         /* Only modify protection if it will not unlock other areas */
1752         if ((status_new & mask) < (status_old & mask))
1753                 return -EINVAL;
1754
1755         return spi_nor_write_sr_and_check(nor, status_new);
1756 }
1757
1758 /*
1759  * Unlock a region of the flash. See spi_nor_sr_lock() for more info
1760  *
1761  * Returns negative on errors, 0 on success.
1762  */
1763 static int spi_nor_sr_unlock(struct spi_nor *nor, loff_t ofs, uint64_t len)
1764 {
1765         struct mtd_info *mtd = &nor->mtd;
1766         u64 min_prot_len;
1767         int ret, status_old, status_new;
1768         u8 mask = spi_nor_get_sr_bp_mask(nor);
1769         u8 tb_mask = spi_nor_get_sr_tb_mask(nor);
1770         u8 pow, val;
1771         loff_t lock_len;
1772         bool can_be_top = true, can_be_bottom = nor->flags & SNOR_F_HAS_SR_TB;
1773         bool use_top;
1774
1775         ret = spi_nor_read_sr(nor, nor->bouncebuf);
1776         if (ret)
1777                 return ret;
1778
1779         status_old = nor->bouncebuf[0];
1780
1781         /* If nothing in our range is locked, we don't need to do anything */
1782         if (spi_nor_is_unlocked_sr(nor, ofs, len, status_old))
1783                 return 0;
1784
1785         /* If anything below us is locked, we can't use 'top' protection */
1786         if (!spi_nor_is_unlocked_sr(nor, 0, ofs, status_old))
1787                 can_be_top = false;
1788
1789         /* If anything above us is locked, we can't use 'bottom' protection */
1790         if (!spi_nor_is_unlocked_sr(nor, ofs + len, mtd->size - (ofs + len),
1791                                     status_old))
1792                 can_be_bottom = false;
1793
1794         if (!can_be_bottom && !can_be_top)
1795                 return -EINVAL;
1796
1797         /* Prefer top, if both are valid */
1798         use_top = can_be_top;
1799
1800         /* lock_len: length of region that should remain locked */
1801         if (use_top)
1802                 lock_len = mtd->size - (ofs + len);
1803         else
1804                 lock_len = ofs;
1805
1806         if (lock_len == 0) {
1807                 val = 0; /* fully unlocked */
1808         } else {
1809                 min_prot_len = spi_nor_get_min_prot_length_sr(nor);
1810                 pow = ilog2(lock_len) - ilog2(min_prot_len) + 1;
1811                 val = pow << SR_BP_SHIFT;
1812
1813                 if (nor->flags & SNOR_F_HAS_SR_BP3_BIT6 && val & SR_BP3)
1814                         val = (val & ~SR_BP3) | SR_BP3_BIT6;
1815
1816                 /* Some power-of-two sizes are not supported */
1817                 if (val & ~mask)
1818                         return -EINVAL;
1819         }
1820
1821         status_new = (status_old & ~mask & ~tb_mask) | val;
1822
1823         /* Don't protect status register if we're fully unlocked */
1824         if (lock_len == 0)
1825                 status_new &= ~SR_SRWD;
1826
1827         if (!use_top)
1828                 status_new |= tb_mask;
1829
1830         /* Don't bother if they're the same */
1831         if (status_new == status_old)
1832                 return 0;
1833
1834         /* Only modify protection if it will not lock other areas */
1835         if ((status_new & mask) > (status_old & mask))
1836                 return -EINVAL;
1837
1838         return spi_nor_write_sr_and_check(nor, status_new);
1839 }
1840
1841 /*
1842  * Check if a region of the flash is (completely) locked. See spi_nor_sr_lock()
1843  * for more info.
1844  *
1845  * Returns 1 if entire region is locked, 0 if any portion is unlocked, and
1846  * negative on errors.
1847  */
1848 static int spi_nor_sr_is_locked(struct spi_nor *nor, loff_t ofs, uint64_t len)
1849 {
1850         int ret;
1851
1852         ret = spi_nor_read_sr(nor, nor->bouncebuf);
1853         if (ret)
1854                 return ret;
1855
1856         return spi_nor_is_locked_sr(nor, ofs, len, nor->bouncebuf[0]);
1857 }
1858
1859 static const struct spi_nor_locking_ops spi_nor_sr_locking_ops = {
1860         .lock = spi_nor_sr_lock,
1861         .unlock = spi_nor_sr_unlock,
1862         .is_locked = spi_nor_sr_is_locked,
1863 };
1864
1865 static int spi_nor_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
1866 {
1867         struct spi_nor *nor = mtd_to_spi_nor(mtd);
1868         int ret;
1869
1870         ret = spi_nor_lock_and_prep(nor);
1871         if (ret)
1872                 return ret;
1873
1874         ret = nor->params->locking_ops->lock(nor, ofs, len);
1875
1876         spi_nor_unlock_and_unprep(nor);
1877         return ret;
1878 }
1879
1880 static int spi_nor_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
1881 {
1882         struct spi_nor *nor = mtd_to_spi_nor(mtd);
1883         int ret;
1884
1885         ret = spi_nor_lock_and_prep(nor);
1886         if (ret)
1887                 return ret;
1888
1889         ret = nor->params->locking_ops->unlock(nor, ofs, len);
1890
1891         spi_nor_unlock_and_unprep(nor);
1892         return ret;
1893 }
1894
1895 static int spi_nor_is_locked(struct mtd_info *mtd, loff_t ofs, uint64_t len)
1896 {
1897         struct spi_nor *nor = mtd_to_spi_nor(mtd);
1898         int ret;
1899
1900         ret = spi_nor_lock_and_prep(nor);
1901         if (ret)
1902                 return ret;
1903
1904         ret = nor->params->locking_ops->is_locked(nor, ofs, len);
1905
1906         spi_nor_unlock_and_unprep(nor);
1907         return ret;
1908 }
1909
1910 /**
1911  * spi_nor_sr1_bit6_quad_enable() - Set the Quad Enable BIT(6) in the Status
1912  * Register 1.
1913  * @nor:        pointer to a 'struct spi_nor'
1914  *
1915  * Bit 6 of the Status Register 1 is the QE bit for Macronix like QSPI memories.
1916  *
1917  * Return: 0 on success, -errno otherwise.
1918  */
1919 int spi_nor_sr1_bit6_quad_enable(struct spi_nor *nor)
1920 {
1921         int ret;
1922
1923         ret = spi_nor_read_sr(nor, nor->bouncebuf);
1924         if (ret)
1925                 return ret;
1926
1927         if (nor->bouncebuf[0] & SR1_QUAD_EN_BIT6)
1928                 return 0;
1929
1930         nor->bouncebuf[0] |= SR1_QUAD_EN_BIT6;
1931
1932         return spi_nor_write_sr1_and_check(nor, nor->bouncebuf[0]);
1933 }
1934
1935 /**
1936  * spi_nor_sr2_bit1_quad_enable() - set the Quad Enable BIT(1) in the Status
1937  * Register 2.
1938  * @nor:       pointer to a 'struct spi_nor'.
1939  *
1940  * Bit 1 of the Status Register 2 is the QE bit for Spansion like QSPI memories.
1941  *
1942  * Return: 0 on success, -errno otherwise.
1943  */
1944 int spi_nor_sr2_bit1_quad_enable(struct spi_nor *nor)
1945 {
1946         int ret;
1947
1948         if (nor->flags & SNOR_F_NO_READ_CR)
1949                 return spi_nor_write_16bit_cr_and_check(nor, SR2_QUAD_EN_BIT1);
1950
1951         ret = spi_nor_read_cr(nor, nor->bouncebuf);
1952         if (ret)
1953                 return ret;
1954
1955         if (nor->bouncebuf[0] & SR2_QUAD_EN_BIT1)
1956                 return 0;
1957
1958         nor->bouncebuf[0] |= SR2_QUAD_EN_BIT1;
1959
1960         return spi_nor_write_16bit_cr_and_check(nor, nor->bouncebuf[0]);
1961 }
1962
1963 /**
1964  * spi_nor_sr2_bit7_quad_enable() - set QE bit in Status Register 2.
1965  * @nor:        pointer to a 'struct spi_nor'
1966  *
1967  * Set the Quad Enable (QE) bit in the Status Register 2.
1968  *
1969  * This is one of the procedures to set the QE bit described in the SFDP
1970  * (JESD216 rev B) specification but no manufacturer using this procedure has
1971  * been identified yet, hence the name of the function.
1972  *
1973  * Return: 0 on success, -errno otherwise.
1974  */
1975 int spi_nor_sr2_bit7_quad_enable(struct spi_nor *nor)
1976 {
1977         u8 *sr2 = nor->bouncebuf;
1978         int ret;
1979         u8 sr2_written;
1980
1981         /* Check current Quad Enable bit value. */
1982         ret = spi_nor_read_sr2(nor, sr2);
1983         if (ret)
1984                 return ret;
1985         if (*sr2 & SR2_QUAD_EN_BIT7)
1986                 return 0;
1987
1988         /* Update the Quad Enable bit. */
1989         *sr2 |= SR2_QUAD_EN_BIT7;
1990
1991         ret = spi_nor_write_sr2(nor, sr2);
1992         if (ret)
1993                 return ret;
1994
1995         sr2_written = *sr2;
1996
1997         /* Read back and check it. */
1998         ret = spi_nor_read_sr2(nor, sr2);
1999         if (ret)
2000                 return ret;
2001
2002         if (*sr2 != sr2_written) {
2003                 dev_dbg(nor->dev, "SR2: Read back test failed\n");
2004                 return -EIO;
2005         }
2006
2007         return 0;
2008 }
2009
2010 static const struct spi_nor_manufacturer *manufacturers[] = {
2011         &spi_nor_atmel,
2012         &spi_nor_catalyst,
2013         &spi_nor_eon,
2014         &spi_nor_esmt,
2015         &spi_nor_everspin,
2016         &spi_nor_fujitsu,
2017         &spi_nor_gigadevice,
2018         &spi_nor_intel,
2019         &spi_nor_issi,
2020         &spi_nor_macronix,
2021         &spi_nor_micron,
2022         &spi_nor_st,
2023         &spi_nor_spansion,
2024         &spi_nor_sst,
2025         &spi_nor_winbond,
2026         &spi_nor_xilinx,
2027         &spi_nor_xmc,
2028 };
2029
2030 static const struct flash_info *
2031 spi_nor_search_part_by_id(const struct flash_info *parts, unsigned int nparts,
2032                           const u8 *id)
2033 {
2034         unsigned int i;
2035
2036         for (i = 0; i < nparts; i++) {
2037                 if (parts[i].id_len &&
2038                     !memcmp(parts[i].id, id, parts[i].id_len))
2039                         return &parts[i];
2040         }
2041
2042         return NULL;
2043 }
2044
2045 static const struct flash_info *spi_nor_read_id(struct spi_nor *nor)
2046 {
2047         const struct flash_info *info;
2048         u8 *id = nor->bouncebuf;
2049         unsigned int i;
2050         int ret;
2051
2052         if (nor->spimem) {
2053                 struct spi_mem_op op =
2054                         SPI_MEM_OP(SPI_MEM_OP_CMD(SPINOR_OP_RDID, 1),
2055                                    SPI_MEM_OP_NO_ADDR,
2056                                    SPI_MEM_OP_NO_DUMMY,
2057                                    SPI_MEM_OP_DATA_IN(SPI_NOR_MAX_ID_LEN, id, 1));
2058
2059                 ret = spi_mem_exec_op(nor->spimem, &op);
2060         } else {
2061                 ret = nor->controller_ops->read_reg(nor, SPINOR_OP_RDID, id,
2062                                                     SPI_NOR_MAX_ID_LEN);
2063         }
2064         if (ret) {
2065                 dev_dbg(nor->dev, "error %d reading JEDEC ID\n", ret);
2066                 return ERR_PTR(ret);
2067         }
2068
2069         for (i = 0; i < ARRAY_SIZE(manufacturers); i++) {
2070                 info = spi_nor_search_part_by_id(manufacturers[i]->parts,
2071                                                  manufacturers[i]->nparts,
2072                                                  id);
2073                 if (info) {
2074                         nor->manufacturer = manufacturers[i];
2075                         return info;
2076                 }
2077         }
2078
2079         dev_err(nor->dev, "unrecognized JEDEC id bytes: %*ph\n",
2080                 SPI_NOR_MAX_ID_LEN, id);
2081         return ERR_PTR(-ENODEV);
2082 }
2083
2084 static int spi_nor_read(struct mtd_info *mtd, loff_t from, size_t len,
2085                         size_t *retlen, u_char *buf)
2086 {
2087         struct spi_nor *nor = mtd_to_spi_nor(mtd);
2088         ssize_t ret;
2089
2090         dev_dbg(nor->dev, "from 0x%08x, len %zd\n", (u32)from, len);
2091
2092         ret = spi_nor_lock_and_prep(nor);
2093         if (ret)
2094                 return ret;
2095
2096         while (len) {
2097                 loff_t addr = from;
2098
2099                 addr = spi_nor_convert_addr(nor, addr);
2100
2101                 ret = spi_nor_read_data(nor, addr, len, buf);
2102                 if (ret == 0) {
2103                         /* We shouldn't see 0-length reads */
2104                         ret = -EIO;
2105                         goto read_err;
2106                 }
2107                 if (ret < 0)
2108                         goto read_err;
2109
2110                 WARN_ON(ret > len);
2111                 *retlen += ret;
2112                 buf += ret;
2113                 from += ret;
2114                 len -= ret;
2115         }
2116         ret = 0;
2117
2118 read_err:
2119         spi_nor_unlock_and_unprep(nor);
2120         return ret;
2121 }
2122
2123 /*
2124  * Write an address range to the nor chip.  Data must be written in
2125  * FLASH_PAGESIZE chunks.  The address range may be any size provided
2126  * it is within the physical boundaries.
2127  */
2128 static int spi_nor_write(struct mtd_info *mtd, loff_t to, size_t len,
2129         size_t *retlen, const u_char *buf)
2130 {
2131         struct spi_nor *nor = mtd_to_spi_nor(mtd);
2132         size_t page_offset, page_remain, i;
2133         ssize_t ret;
2134
2135         dev_dbg(nor->dev, "to 0x%08x, len %zd\n", (u32)to, len);
2136
2137         ret = spi_nor_lock_and_prep(nor);
2138         if (ret)
2139                 return ret;
2140
2141         for (i = 0; i < len; ) {
2142                 ssize_t written;
2143                 loff_t addr = to + i;
2144
2145                 /*
2146                  * If page_size is a power of two, the offset can be quickly
2147                  * calculated with an AND operation. On the other cases we
2148                  * need to do a modulus operation (more expensive).
2149                  * Power of two numbers have only one bit set and we can use
2150                  * the instruction hweight32 to detect if we need to do a
2151                  * modulus (do_div()) or not.
2152                  */
2153                 if (hweight32(nor->page_size) == 1) {
2154                         page_offset = addr & (nor->page_size - 1);
2155                 } else {
2156                         uint64_t aux = addr;
2157
2158                         page_offset = do_div(aux, nor->page_size);
2159                 }
2160                 /* the size of data remaining on the first page */
2161                 page_remain = min_t(size_t,
2162                                     nor->page_size - page_offset, len - i);
2163
2164                 addr = spi_nor_convert_addr(nor, addr);
2165
2166                 ret = spi_nor_write_enable(nor);
2167                 if (ret)
2168                         goto write_err;
2169
2170                 ret = spi_nor_write_data(nor, addr, page_remain, buf + i);
2171                 if (ret < 0)
2172                         goto write_err;
2173                 written = ret;
2174
2175                 ret = spi_nor_wait_till_ready(nor);
2176                 if (ret)
2177                         goto write_err;
2178                 *retlen += written;
2179                 i += written;
2180         }
2181
2182 write_err:
2183         spi_nor_unlock_and_unprep(nor);
2184         return ret;
2185 }
2186
2187 static int spi_nor_check(struct spi_nor *nor)
2188 {
2189         if (!nor->dev ||
2190             (!nor->spimem && !nor->controller_ops) ||
2191             (!nor->spimem && nor->controller_ops &&
2192             (!nor->controller_ops->read ||
2193              !nor->controller_ops->write ||
2194              !nor->controller_ops->read_reg ||
2195              !nor->controller_ops->write_reg))) {
2196                 pr_err("spi-nor: please fill all the necessary fields!\n");
2197                 return -EINVAL;
2198         }
2199
2200         if (nor->spimem && nor->controller_ops) {
2201                 dev_err(nor->dev, "nor->spimem and nor->controller_ops are mutually exclusive, please set just one of them.\n");
2202                 return -EINVAL;
2203         }
2204
2205         return 0;
2206 }
2207
2208 static void
2209 spi_nor_set_read_settings(struct spi_nor_read_command *read,
2210                           u8 num_mode_clocks,
2211                           u8 num_wait_states,
2212                           u8 opcode,
2213                           enum spi_nor_protocol proto)
2214 {
2215         read->num_mode_clocks = num_mode_clocks;
2216         read->num_wait_states = num_wait_states;
2217         read->opcode = opcode;
2218         read->proto = proto;
2219 }
2220
2221 void spi_nor_set_pp_settings(struct spi_nor_pp_command *pp, u8 opcode,
2222                              enum spi_nor_protocol proto)
2223 {
2224         pp->opcode = opcode;
2225         pp->proto = proto;
2226 }
2227
2228 static int spi_nor_hwcaps2cmd(u32 hwcaps, const int table[][2], size_t size)
2229 {
2230         size_t i;
2231
2232         for (i = 0; i < size; i++)
2233                 if (table[i][0] == (int)hwcaps)
2234                         return table[i][1];
2235
2236         return -EINVAL;
2237 }
2238
2239 int spi_nor_hwcaps_read2cmd(u32 hwcaps)
2240 {
2241         static const int hwcaps_read2cmd[][2] = {
2242                 { SNOR_HWCAPS_READ,             SNOR_CMD_READ },
2243                 { SNOR_HWCAPS_READ_FAST,        SNOR_CMD_READ_FAST },
2244                 { SNOR_HWCAPS_READ_1_1_1_DTR,   SNOR_CMD_READ_1_1_1_DTR },
2245                 { SNOR_HWCAPS_READ_1_1_2,       SNOR_CMD_READ_1_1_2 },
2246                 { SNOR_HWCAPS_READ_1_2_2,       SNOR_CMD_READ_1_2_2 },
2247                 { SNOR_HWCAPS_READ_2_2_2,       SNOR_CMD_READ_2_2_2 },
2248                 { SNOR_HWCAPS_READ_1_2_2_DTR,   SNOR_CMD_READ_1_2_2_DTR },
2249                 { SNOR_HWCAPS_READ_1_1_4,       SNOR_CMD_READ_1_1_4 },
2250                 { SNOR_HWCAPS_READ_1_4_4,       SNOR_CMD_READ_1_4_4 },
2251                 { SNOR_HWCAPS_READ_4_4_4,       SNOR_CMD_READ_4_4_4 },
2252                 { SNOR_HWCAPS_READ_1_4_4_DTR,   SNOR_CMD_READ_1_4_4_DTR },
2253                 { SNOR_HWCAPS_READ_1_1_8,       SNOR_CMD_READ_1_1_8 },
2254                 { SNOR_HWCAPS_READ_1_8_8,       SNOR_CMD_READ_1_8_8 },
2255                 { SNOR_HWCAPS_READ_8_8_8,       SNOR_CMD_READ_8_8_8 },
2256                 { SNOR_HWCAPS_READ_1_8_8_DTR,   SNOR_CMD_READ_1_8_8_DTR },
2257         };
2258
2259         return spi_nor_hwcaps2cmd(hwcaps, hwcaps_read2cmd,
2260                                   ARRAY_SIZE(hwcaps_read2cmd));
2261 }
2262
2263 static int spi_nor_hwcaps_pp2cmd(u32 hwcaps)
2264 {
2265         static const int hwcaps_pp2cmd[][2] = {
2266                 { SNOR_HWCAPS_PP,               SNOR_CMD_PP },
2267                 { SNOR_HWCAPS_PP_1_1_4,         SNOR_CMD_PP_1_1_4 },
2268                 { SNOR_HWCAPS_PP_1_4_4,         SNOR_CMD_PP_1_4_4 },
2269                 { SNOR_HWCAPS_PP_4_4_4,         SNOR_CMD_PP_4_4_4 },
2270                 { SNOR_HWCAPS_PP_1_1_8,         SNOR_CMD_PP_1_1_8 },
2271                 { SNOR_HWCAPS_PP_1_8_8,         SNOR_CMD_PP_1_8_8 },
2272                 { SNOR_HWCAPS_PP_8_8_8,         SNOR_CMD_PP_8_8_8 },
2273         };
2274
2275         return spi_nor_hwcaps2cmd(hwcaps, hwcaps_pp2cmd,
2276                                   ARRAY_SIZE(hwcaps_pp2cmd));
2277 }
2278
2279 /**
2280  * spi_nor_spimem_check_op - check if the operation is supported
2281  *                           by controller
2282  *@nor:        pointer to a 'struct spi_nor'
2283  *@op:         pointer to op template to be checked
2284  *
2285  * Returns 0 if operation is supported, -ENOTSUPP otherwise.
2286  */
2287 static int spi_nor_spimem_check_op(struct spi_nor *nor,
2288                                    struct spi_mem_op *op)
2289 {
2290         /*
2291          * First test with 4 address bytes. The opcode itself might
2292          * be a 3B addressing opcode but we don't care, because
2293          * SPI controller implementation should not check the opcode,
2294          * but just the sequence.
2295          */
2296         op->addr.nbytes = 4;
2297         if (!spi_mem_supports_op(nor->spimem, op)) {
2298                 if (nor->mtd.size > SZ_16M)
2299                         return -ENOTSUPP;
2300
2301                 /* If flash size <= 16MB, 3 address bytes are sufficient */
2302                 op->addr.nbytes = 3;
2303                 if (!spi_mem_supports_op(nor->spimem, op))
2304                         return -ENOTSUPP;
2305         }
2306
2307         return 0;
2308 }
2309
2310 /**
2311  * spi_nor_spimem_check_readop - check if the read op is supported
2312  *                               by controller
2313  *@nor:         pointer to a 'struct spi_nor'
2314  *@read:        pointer to op template to be checked
2315  *
2316  * Returns 0 if operation is supported, -ENOTSUPP otherwise.
2317  */
2318 static int spi_nor_spimem_check_readop(struct spi_nor *nor,
2319                                        const struct spi_nor_read_command *read)
2320 {
2321         struct spi_mem_op op = SPI_MEM_OP(SPI_MEM_OP_CMD(read->opcode, 1),
2322                                           SPI_MEM_OP_ADDR(3, 0, 1),
2323                                           SPI_MEM_OP_DUMMY(0, 1),
2324                                           SPI_MEM_OP_DATA_IN(0, NULL, 1));
2325
2326         op.cmd.buswidth = spi_nor_get_protocol_inst_nbits(read->proto);
2327         op.addr.buswidth = spi_nor_get_protocol_addr_nbits(read->proto);
2328         op.data.buswidth = spi_nor_get_protocol_data_nbits(read->proto);
2329         op.dummy.buswidth = op.addr.buswidth;
2330         op.dummy.nbytes = (read->num_mode_clocks + read->num_wait_states) *
2331                           op.dummy.buswidth / 8;
2332
2333         return spi_nor_spimem_check_op(nor, &op);
2334 }
2335
2336 /**
2337  * spi_nor_spimem_check_pp - check if the page program op is supported
2338  *                           by controller
2339  *@nor:         pointer to a 'struct spi_nor'
2340  *@pp:          pointer to op template to be checked
2341  *
2342  * Returns 0 if operation is supported, -ENOTSUPP otherwise.
2343  */
2344 static int spi_nor_spimem_check_pp(struct spi_nor *nor,
2345                                    const struct spi_nor_pp_command *pp)
2346 {
2347         struct spi_mem_op op = SPI_MEM_OP(SPI_MEM_OP_CMD(pp->opcode, 1),
2348                                           SPI_MEM_OP_ADDR(3, 0, 1),
2349                                           SPI_MEM_OP_NO_DUMMY,
2350                                           SPI_MEM_OP_DATA_OUT(0, NULL, 1));
2351
2352         op.cmd.buswidth = spi_nor_get_protocol_inst_nbits(pp->proto);
2353         op.addr.buswidth = spi_nor_get_protocol_addr_nbits(pp->proto);
2354         op.data.buswidth = spi_nor_get_protocol_data_nbits(pp->proto);
2355
2356         return spi_nor_spimem_check_op(nor, &op);
2357 }
2358
2359 /**
2360  * spi_nor_spimem_adjust_hwcaps - Find optimal Read/Write protocol
2361  *                                based on SPI controller capabilities
2362  * @nor:        pointer to a 'struct spi_nor'
2363  * @hwcaps:     pointer to resulting capabilities after adjusting
2364  *              according to controller and flash's capability
2365  */
2366 static void
2367 spi_nor_spimem_adjust_hwcaps(struct spi_nor *nor, u32 *hwcaps)
2368 {
2369         struct spi_nor_flash_parameter *params = nor->params;
2370         unsigned int cap;
2371
2372         /* DTR modes are not supported yet, mask them all. */
2373         *hwcaps &= ~SNOR_HWCAPS_DTR;
2374
2375         /* X-X-X modes are not supported yet, mask them all. */
2376         *hwcaps &= ~SNOR_HWCAPS_X_X_X;
2377
2378         for (cap = 0; cap < sizeof(*hwcaps) * BITS_PER_BYTE; cap++) {
2379                 int rdidx, ppidx;
2380
2381                 if (!(*hwcaps & BIT(cap)))
2382                         continue;
2383
2384                 rdidx = spi_nor_hwcaps_read2cmd(BIT(cap));
2385                 if (rdidx >= 0 &&
2386                     spi_nor_spimem_check_readop(nor, &params->reads[rdidx]))
2387                         *hwcaps &= ~BIT(cap);
2388
2389                 ppidx = spi_nor_hwcaps_pp2cmd(BIT(cap));
2390                 if (ppidx < 0)
2391                         continue;
2392
2393                 if (spi_nor_spimem_check_pp(nor,
2394                                             &params->page_programs[ppidx]))
2395                         *hwcaps &= ~BIT(cap);
2396         }
2397 }
2398
2399 /**
2400  * spi_nor_set_erase_type() - set a SPI NOR erase type
2401  * @erase:      pointer to a structure that describes a SPI NOR erase type
2402  * @size:       the size of the sector/block erased by the erase type
2403  * @opcode:     the SPI command op code to erase the sector/block
2404  */
2405 void spi_nor_set_erase_type(struct spi_nor_erase_type *erase, u32 size,
2406                             u8 opcode)
2407 {
2408         erase->size = size;
2409         erase->opcode = opcode;
2410         /* JEDEC JESD216B Standard imposes erase sizes to be power of 2. */
2411         erase->size_shift = ffs(erase->size) - 1;
2412         erase->size_mask = (1 << erase->size_shift) - 1;
2413 }
2414
2415 /**
2416  * spi_nor_init_uniform_erase_map() - Initialize uniform erase map
2417  * @map:                the erase map of the SPI NOR
2418  * @erase_mask:         bitmask encoding erase types that can erase the entire
2419  *                      flash memory
2420  * @flash_size:         the spi nor flash memory size
2421  */
2422 void spi_nor_init_uniform_erase_map(struct spi_nor_erase_map *map,
2423                                     u8 erase_mask, u64 flash_size)
2424 {
2425         /* Offset 0 with erase_mask and SNOR_LAST_REGION bit set */
2426         map->uniform_region.offset = (erase_mask & SNOR_ERASE_TYPE_MASK) |
2427                                      SNOR_LAST_REGION;
2428         map->uniform_region.size = flash_size;
2429         map->regions = &map->uniform_region;
2430         map->uniform_erase_type = erase_mask;
2431 }
2432
2433 int spi_nor_post_bfpt_fixups(struct spi_nor *nor,
2434                              const struct sfdp_parameter_header *bfpt_header,
2435                              const struct sfdp_bfpt *bfpt,
2436                              struct spi_nor_flash_parameter *params)
2437 {
2438         int ret;
2439
2440         if (nor->manufacturer && nor->manufacturer->fixups &&
2441             nor->manufacturer->fixups->post_bfpt) {
2442                 ret = nor->manufacturer->fixups->post_bfpt(nor, bfpt_header,
2443                                                            bfpt, params);
2444                 if (ret)
2445                         return ret;
2446         }
2447
2448         if (nor->info->fixups && nor->info->fixups->post_bfpt)
2449                 return nor->info->fixups->post_bfpt(nor, bfpt_header, bfpt,
2450                                                     params);
2451
2452         return 0;
2453 }
2454
2455 static int spi_nor_select_read(struct spi_nor *nor,
2456                                u32 shared_hwcaps)
2457 {
2458         int cmd, best_match = fls(shared_hwcaps & SNOR_HWCAPS_READ_MASK) - 1;
2459         const struct spi_nor_read_command *read;
2460
2461         if (best_match < 0)
2462                 return -EINVAL;
2463
2464         cmd = spi_nor_hwcaps_read2cmd(BIT(best_match));
2465         if (cmd < 0)
2466                 return -EINVAL;
2467
2468         read = &nor->params->reads[cmd];
2469         nor->read_opcode = read->opcode;
2470         nor->read_proto = read->proto;
2471
2472         /*
2473          * In the SPI NOR framework, we don't need to make the difference
2474          * between mode clock cycles and wait state clock cycles.
2475          * Indeed, the value of the mode clock cycles is used by a QSPI
2476          * flash memory to know whether it should enter or leave its 0-4-4
2477          * (Continuous Read / XIP) mode.
2478          * eXecution In Place is out of the scope of the mtd sub-system.
2479          * Hence we choose to merge both mode and wait state clock cycles
2480          * into the so called dummy clock cycles.
2481          */
2482         nor->read_dummy = read->num_mode_clocks + read->num_wait_states;
2483         return 0;
2484 }
2485
2486 static int spi_nor_select_pp(struct spi_nor *nor,
2487                              u32 shared_hwcaps)
2488 {
2489         int cmd, best_match = fls(shared_hwcaps & SNOR_HWCAPS_PP_MASK) - 1;
2490         const struct spi_nor_pp_command *pp;
2491
2492         if (best_match < 0)
2493                 return -EINVAL;
2494
2495         cmd = spi_nor_hwcaps_pp2cmd(BIT(best_match));
2496         if (cmd < 0)
2497                 return -EINVAL;
2498
2499         pp = &nor->params->page_programs[cmd];
2500         nor->program_opcode = pp->opcode;
2501         nor->write_proto = pp->proto;
2502         return 0;
2503 }
2504
2505 /**
2506  * spi_nor_select_uniform_erase() - select optimum uniform erase type
2507  * @map:                the erase map of the SPI NOR
2508  * @wanted_size:        the erase type size to search for. Contains the value of
2509  *                      info->sector_size or of the "small sector" size in case
2510  *                      CONFIG_MTD_SPI_NOR_USE_4K_SECTORS is defined.
2511  *
2512  * Once the optimum uniform sector erase command is found, disable all the
2513  * other.
2514  *
2515  * Return: pointer to erase type on success, NULL otherwise.
2516  */
2517 static const struct spi_nor_erase_type *
2518 spi_nor_select_uniform_erase(struct spi_nor_erase_map *map,
2519                              const u32 wanted_size)
2520 {
2521         const struct spi_nor_erase_type *tested_erase, *erase = NULL;
2522         int i;
2523         u8 uniform_erase_type = map->uniform_erase_type;
2524
2525         for (i = SNOR_ERASE_TYPE_MAX - 1; i >= 0; i--) {
2526                 if (!(uniform_erase_type & BIT(i)))
2527                         continue;
2528
2529                 tested_erase = &map->erase_type[i];
2530
2531                 /*
2532                  * If the current erase size is the one, stop here:
2533                  * we have found the right uniform Sector Erase command.
2534                  */
2535                 if (tested_erase->size == wanted_size) {
2536                         erase = tested_erase;
2537                         break;
2538                 }
2539
2540                 /*
2541                  * Otherwise, the current erase size is still a valid canditate.
2542                  * Select the biggest valid candidate.
2543                  */
2544                 if (!erase && tested_erase->size)
2545                         erase = tested_erase;
2546                         /* keep iterating to find the wanted_size */
2547         }
2548
2549         if (!erase)
2550                 return NULL;
2551
2552         /* Disable all other Sector Erase commands. */
2553         map->uniform_erase_type &= ~SNOR_ERASE_TYPE_MASK;
2554         map->uniform_erase_type |= BIT(erase - map->erase_type);
2555         return erase;
2556 }
2557
2558 static int spi_nor_select_erase(struct spi_nor *nor)
2559 {
2560         struct spi_nor_erase_map *map = &nor->params->erase_map;
2561         const struct spi_nor_erase_type *erase = NULL;
2562         struct mtd_info *mtd = &nor->mtd;
2563         u32 wanted_size = nor->info->sector_size;
2564         int i;
2565
2566         /*
2567          * The previous implementation handling Sector Erase commands assumed
2568          * that the SPI flash memory has an uniform layout then used only one
2569          * of the supported erase sizes for all Sector Erase commands.
2570          * So to be backward compatible, the new implementation also tries to
2571          * manage the SPI flash memory as uniform with a single erase sector
2572          * size, when possible.
2573          */
2574 #ifdef CONFIG_MTD_SPI_NOR_USE_4K_SECTORS
2575         /* prefer "small sector" erase if possible */
2576         wanted_size = 4096u;
2577 #endif
2578
2579         if (spi_nor_has_uniform_erase(nor)) {
2580                 erase = spi_nor_select_uniform_erase(map, wanted_size);
2581                 if (!erase)
2582                         return -EINVAL;
2583                 nor->erase_opcode = erase->opcode;
2584                 mtd->erasesize = erase->size;
2585                 return 0;
2586         }
2587
2588         /*
2589          * For non-uniform SPI flash memory, set mtd->erasesize to the
2590          * maximum erase sector size. No need to set nor->erase_opcode.
2591          */
2592         for (i = SNOR_ERASE_TYPE_MAX - 1; i >= 0; i--) {
2593                 if (map->erase_type[i].size) {
2594                         erase = &map->erase_type[i];
2595                         break;
2596                 }
2597         }
2598
2599         if (!erase)
2600                 return -EINVAL;
2601
2602         mtd->erasesize = erase->size;
2603         return 0;
2604 }
2605
2606 static int spi_nor_default_setup(struct spi_nor *nor,
2607                                  const struct spi_nor_hwcaps *hwcaps)
2608 {
2609         struct spi_nor_flash_parameter *params = nor->params;
2610         u32 ignored_mask, shared_mask;
2611         int err;
2612
2613         /*
2614          * Keep only the hardware capabilities supported by both the SPI
2615          * controller and the SPI flash memory.
2616          */
2617         shared_mask = hwcaps->mask & params->hwcaps.mask;
2618
2619         if (nor->spimem) {
2620                 /*
2621                  * When called from spi_nor_probe(), all caps are set and we
2622                  * need to discard some of them based on what the SPI
2623                  * controller actually supports (using spi_mem_supports_op()).
2624                  */
2625                 spi_nor_spimem_adjust_hwcaps(nor, &shared_mask);
2626         } else {
2627                 /*
2628                  * SPI n-n-n protocols are not supported when the SPI
2629                  * controller directly implements the spi_nor interface.
2630                  * Yet another reason to switch to spi-mem.
2631                  */
2632                 ignored_mask = SNOR_HWCAPS_X_X_X;
2633                 if (shared_mask & ignored_mask) {
2634                         dev_dbg(nor->dev,
2635                                 "SPI n-n-n protocols are not supported.\n");
2636                         shared_mask &= ~ignored_mask;
2637                 }
2638         }
2639
2640         /* Select the (Fast) Read command. */
2641         err = spi_nor_select_read(nor, shared_mask);
2642         if (err) {
2643                 dev_dbg(nor->dev,
2644                         "can't select read settings supported by both the SPI controller and memory.\n");
2645                 return err;
2646         }
2647
2648         /* Select the Page Program command. */
2649         err = spi_nor_select_pp(nor, shared_mask);
2650         if (err) {
2651                 dev_dbg(nor->dev,
2652                         "can't select write settings supported by both the SPI controller and memory.\n");
2653                 return err;
2654         }
2655
2656         /* Select the Sector Erase command. */
2657         err = spi_nor_select_erase(nor);
2658         if (err) {
2659                 dev_dbg(nor->dev,
2660                         "can't select erase settings supported by both the SPI controller and memory.\n");
2661                 return err;
2662         }
2663
2664         return 0;
2665 }
2666
2667 static int spi_nor_setup(struct spi_nor *nor,
2668                          const struct spi_nor_hwcaps *hwcaps)
2669 {
2670         if (!nor->params->setup)
2671                 return 0;
2672
2673         return nor->params->setup(nor, hwcaps);
2674 }
2675
2676 /**
2677  * spi_nor_manufacturer_init_params() - Initialize the flash's parameters and
2678  * settings based on MFR register and ->default_init() hook.
2679  * @nor:        pointer to a 'struct spi_nor'.
2680  */
2681 static void spi_nor_manufacturer_init_params(struct spi_nor *nor)
2682 {
2683         if (nor->manufacturer && nor->manufacturer->fixups &&
2684             nor->manufacturer->fixups->default_init)
2685                 nor->manufacturer->fixups->default_init(nor);
2686
2687         if (nor->info->fixups && nor->info->fixups->default_init)
2688                 nor->info->fixups->default_init(nor);
2689 }
2690
2691 /**
2692  * spi_nor_sfdp_init_params() - Initialize the flash's parameters and settings
2693  * based on JESD216 SFDP standard.
2694  * @nor:        pointer to a 'struct spi_nor'.
2695  *
2696  * The method has a roll-back mechanism: in case the SFDP parsing fails, the
2697  * legacy flash parameters and settings will be restored.
2698  */
2699 static void spi_nor_sfdp_init_params(struct spi_nor *nor)
2700 {
2701         struct spi_nor_flash_parameter sfdp_params;
2702
2703         memcpy(&sfdp_params, nor->params, sizeof(sfdp_params));
2704
2705         if (spi_nor_parse_sfdp(nor, nor->params)) {
2706                 memcpy(nor->params, &sfdp_params, sizeof(*nor->params));
2707                 nor->addr_width = 0;
2708                 nor->flags &= ~SNOR_F_4B_OPCODES;
2709         }
2710 }
2711
2712 /**
2713  * spi_nor_info_init_params() - Initialize the flash's parameters and settings
2714  * based on nor->info data.
2715  * @nor:        pointer to a 'struct spi_nor'.
2716  */
2717 static void spi_nor_info_init_params(struct spi_nor *nor)
2718 {
2719         struct spi_nor_flash_parameter *params = nor->params;
2720         struct spi_nor_erase_map *map = &params->erase_map;
2721         const struct flash_info *info = nor->info;
2722         struct device_node *np = spi_nor_get_flash_node(nor);
2723         u8 i, erase_mask;
2724
2725         /* Initialize legacy flash parameters and settings. */
2726         params->quad_enable = spi_nor_sr2_bit1_quad_enable;
2727         params->set_4byte_addr_mode = spansion_set_4byte_addr_mode;
2728         params->setup = spi_nor_default_setup;
2729         /* Default to 16-bit Write Status (01h) Command */
2730         nor->flags |= SNOR_F_HAS_16BIT_SR;
2731
2732         /* Set SPI NOR sizes. */
2733         params->size = (u64)info->sector_size * info->n_sectors;
2734         params->page_size = info->page_size;
2735
2736         if (!(info->flags & SPI_NOR_NO_FR)) {
2737                 /* Default to Fast Read for DT and non-DT platform devices. */
2738                 params->hwcaps.mask |= SNOR_HWCAPS_READ_FAST;
2739
2740                 /* Mask out Fast Read if not requested at DT instantiation. */
2741                 if (np && !of_property_read_bool(np, "m25p,fast-read"))
2742                         params->hwcaps.mask &= ~SNOR_HWCAPS_READ_FAST;
2743         }
2744
2745         /* (Fast) Read settings. */
2746         params->hwcaps.mask |= SNOR_HWCAPS_READ;
2747         spi_nor_set_read_settings(&params->reads[SNOR_CMD_READ],
2748                                   0, 0, SPINOR_OP_READ,
2749                                   SNOR_PROTO_1_1_1);
2750
2751         if (params->hwcaps.mask & SNOR_HWCAPS_READ_FAST)
2752                 spi_nor_set_read_settings(&params->reads[SNOR_CMD_READ_FAST],
2753                                           0, 8, SPINOR_OP_READ_FAST,
2754                                           SNOR_PROTO_1_1_1);
2755
2756         if (info->flags & SPI_NOR_DUAL_READ) {
2757                 params->hwcaps.mask |= SNOR_HWCAPS_READ_1_1_2;
2758                 spi_nor_set_read_settings(&params->reads[SNOR_CMD_READ_1_1_2],
2759                                           0, 8, SPINOR_OP_READ_1_1_2,
2760                                           SNOR_PROTO_1_1_2);
2761         }
2762
2763         if (info->flags & SPI_NOR_QUAD_READ) {
2764                 params->hwcaps.mask |= SNOR_HWCAPS_READ_1_1_4;
2765                 spi_nor_set_read_settings(&params->reads[SNOR_CMD_READ_1_1_4],
2766                                           0, 8, SPINOR_OP_READ_1_1_4,
2767                                           SNOR_PROTO_1_1_4);
2768         }
2769
2770         if (info->flags & SPI_NOR_OCTAL_READ) {
2771                 params->hwcaps.mask |= SNOR_HWCAPS_READ_1_1_8;
2772                 spi_nor_set_read_settings(&params->reads[SNOR_CMD_READ_1_1_8],
2773                                           0, 8, SPINOR_OP_READ_1_1_8,
2774                                           SNOR_PROTO_1_1_8);
2775         }
2776
2777         /* Page Program settings. */
2778         params->hwcaps.mask |= SNOR_HWCAPS_PP;
2779         spi_nor_set_pp_settings(&params->page_programs[SNOR_CMD_PP],
2780                                 SPINOR_OP_PP, SNOR_PROTO_1_1_1);
2781
2782         /*
2783          * Sector Erase settings. Sort Erase Types in ascending order, with the
2784          * smallest erase size starting at BIT(0).
2785          */
2786         erase_mask = 0;
2787         i = 0;
2788         if (info->flags & SECT_4K_PMC) {
2789                 erase_mask |= BIT(i);
2790                 spi_nor_set_erase_type(&map->erase_type[i], 4096u,
2791                                        SPINOR_OP_BE_4K_PMC);
2792                 i++;
2793         } else if (info->flags & SECT_4K) {
2794                 erase_mask |= BIT(i);
2795                 spi_nor_set_erase_type(&map->erase_type[i], 4096u,
2796                                        SPINOR_OP_BE_4K);
2797                 i++;
2798         }
2799         erase_mask |= BIT(i);
2800         spi_nor_set_erase_type(&map->erase_type[i], info->sector_size,
2801                                SPINOR_OP_SE);
2802         spi_nor_init_uniform_erase_map(map, erase_mask, params->size);
2803 }
2804
2805 /**
2806  * spi_nor_post_sfdp_fixups() - Updates the flash's parameters and settings
2807  * after SFDP has been parsed (is also called for SPI NORs that do not
2808  * support RDSFDP).
2809  * @nor:        pointer to a 'struct spi_nor'
2810  *
2811  * Typically used to tweak various parameters that could not be extracted by
2812  * other means (i.e. when information provided by the SFDP/flash_info tables
2813  * are incomplete or wrong).
2814  */
2815 static void spi_nor_post_sfdp_fixups(struct spi_nor *nor)
2816 {
2817         if (nor->manufacturer && nor->manufacturer->fixups &&
2818             nor->manufacturer->fixups->post_sfdp)
2819                 nor->manufacturer->fixups->post_sfdp(nor);
2820
2821         if (nor->info->fixups && nor->info->fixups->post_sfdp)
2822                 nor->info->fixups->post_sfdp(nor);
2823 }
2824
2825 /**
2826  * spi_nor_late_init_params() - Late initialization of default flash parameters.
2827  * @nor:        pointer to a 'struct spi_nor'
2828  *
2829  * Used to set default flash parameters and settings when the ->default_init()
2830  * hook or the SFDP parser let voids.
2831  */
2832 static void spi_nor_late_init_params(struct spi_nor *nor)
2833 {
2834         /*
2835          * NOR protection support. When locking_ops are not provided, we pick
2836          * the default ones.
2837          */
2838         if (nor->flags & SNOR_F_HAS_LOCK && !nor->params->locking_ops)
2839                 nor->params->locking_ops = &spi_nor_sr_locking_ops;
2840 }
2841
2842 /**
2843  * spi_nor_init_params() - Initialize the flash's parameters and settings.
2844  * @nor:        pointer to a 'struct spi_nor'.
2845  *
2846  * The flash parameters and settings are initialized based on a sequence of
2847  * calls that are ordered by priority:
2848  *
2849  * 1/ Default flash parameters initialization. The initializations are done
2850  *    based on nor->info data:
2851  *              spi_nor_info_init_params()
2852  *
2853  * which can be overwritten by:
2854  * 2/ Manufacturer flash parameters initialization. The initializations are
2855  *    done based on MFR register, or when the decisions can not be done solely
2856  *    based on MFR, by using specific flash_info tweeks, ->default_init():
2857  *              spi_nor_manufacturer_init_params()
2858  *
2859  * which can be overwritten by:
2860  * 3/ SFDP flash parameters initialization. JESD216 SFDP is a standard and
2861  *    should be more accurate that the above.
2862  *              spi_nor_sfdp_init_params()
2863  *
2864  *    Please note that there is a ->post_bfpt() fixup hook that can overwrite
2865  *    the flash parameters and settings immediately after parsing the Basic
2866  *    Flash Parameter Table.
2867  *
2868  * which can be overwritten by:
2869  * 4/ Post SFDP flash parameters initialization. Used to tweak various
2870  *    parameters that could not be extracted by other means (i.e. when
2871  *    information provided by the SFDP/flash_info tables are incomplete or
2872  *    wrong).
2873  *              spi_nor_post_sfdp_fixups()
2874  *
2875  * 5/ Late default flash parameters initialization, used when the
2876  * ->default_init() hook or the SFDP parser do not set specific params.
2877  *              spi_nor_late_init_params()
2878  */
2879 static int spi_nor_init_params(struct spi_nor *nor)
2880 {
2881         nor->params = devm_kzalloc(nor->dev, sizeof(*nor->params), GFP_KERNEL);
2882         if (!nor->params)
2883                 return -ENOMEM;
2884
2885         spi_nor_info_init_params(nor);
2886
2887         spi_nor_manufacturer_init_params(nor);
2888
2889         if ((nor->info->flags & (SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ)) &&
2890             !(nor->info->flags & SPI_NOR_SKIP_SFDP))
2891                 spi_nor_sfdp_init_params(nor);
2892
2893         spi_nor_post_sfdp_fixups(nor);
2894
2895         spi_nor_late_init_params(nor);
2896
2897         return 0;
2898 }
2899
2900 /**
2901  * spi_nor_quad_enable() - enable Quad I/O if needed.
2902  * @nor:                pointer to a 'struct spi_nor'
2903  *
2904  * Return: 0 on success, -errno otherwise.
2905  */
2906 static int spi_nor_quad_enable(struct spi_nor *nor)
2907 {
2908         if (!nor->params->quad_enable)
2909                 return 0;
2910
2911         if (!(spi_nor_get_protocol_width(nor->read_proto) == 4 ||
2912               spi_nor_get_protocol_width(nor->write_proto) == 4))
2913                 return 0;
2914
2915         return nor->params->quad_enable(nor);
2916 }
2917
2918 /**
2919  * spi_nor_try_unlock_all() - Tries to unlock the entire flash memory array.
2920  * @nor:        pointer to a 'struct spi_nor'.
2921  *
2922  * Some SPI NOR flashes are write protected by default after a power-on reset
2923  * cycle, in order to avoid inadvertent writes during power-up. Backward
2924  * compatibility imposes to unlock the entire flash memory array at power-up
2925  * by default.
2926  *
2927  * Unprotecting the entire flash array will fail for boards which are hardware
2928  * write-protected. Thus any errors are ignored.
2929  */
2930 static void spi_nor_try_unlock_all(struct spi_nor *nor)
2931 {
2932         int ret;
2933
2934         if (!(nor->flags & SNOR_F_HAS_LOCK))
2935                 return;
2936
2937         ret = spi_nor_unlock(&nor->mtd, 0, nor->params->size);
2938         if (ret)
2939                 dev_dbg(nor->dev, "Failed to unlock the entire flash memory array\n");
2940 }
2941
2942 static int spi_nor_init(struct spi_nor *nor)
2943 {
2944         int err;
2945
2946         err = spi_nor_quad_enable(nor);
2947         if (err) {
2948                 dev_dbg(nor->dev, "quad mode not supported\n");
2949                 return err;
2950         }
2951
2952         spi_nor_try_unlock_all(nor);
2953
2954         if (nor->addr_width == 4 && !(nor->flags & SNOR_F_4B_OPCODES)) {
2955                 /*
2956                  * If the RESET# pin isn't hooked up properly, or the system
2957                  * otherwise doesn't perform a reset command in the boot
2958                  * sequence, it's impossible to 100% protect against unexpected
2959                  * reboots (e.g., crashes). Warn the user (or hopefully, system
2960                  * designer) that this is bad.
2961                  */
2962                 WARN_ONCE(nor->flags & SNOR_F_BROKEN_RESET,
2963                           "enabling reset hack; may not recover from unexpected reboots\n");
2964                 nor->params->set_4byte_addr_mode(nor, true);
2965         }
2966
2967         return 0;
2968 }
2969
2970 /* mtd resume handler */
2971 static void spi_nor_resume(struct mtd_info *mtd)
2972 {
2973         struct spi_nor *nor = mtd_to_spi_nor(mtd);
2974         struct device *dev = nor->dev;
2975         int ret;
2976
2977         /* re-initialize the nor chip */
2978         ret = spi_nor_init(nor);
2979         if (ret)
2980                 dev_err(dev, "resume() failed\n");
2981 }
2982
2983 void spi_nor_restore(struct spi_nor *nor)
2984 {
2985         /* restore the addressing mode */
2986         if (nor->addr_width == 4 && !(nor->flags & SNOR_F_4B_OPCODES) &&
2987             nor->flags & SNOR_F_BROKEN_RESET)
2988                 nor->params->set_4byte_addr_mode(nor, false);
2989 }
2990 EXPORT_SYMBOL_GPL(spi_nor_restore);
2991
2992 static const struct flash_info *spi_nor_match_id(struct spi_nor *nor,
2993                                                  const char *name)
2994 {
2995         unsigned int i, j;
2996
2997         for (i = 0; i < ARRAY_SIZE(manufacturers); i++) {
2998                 for (j = 0; j < manufacturers[i]->nparts; j++) {
2999                         if (!strcmp(name, manufacturers[i]->parts[j].name)) {
3000                                 nor->manufacturer = manufacturers[i];
3001                                 return &manufacturers[i]->parts[j];
3002                         }
3003                 }
3004         }
3005
3006         return NULL;
3007 }
3008
3009 static int spi_nor_set_addr_width(struct spi_nor *nor)
3010 {
3011         if (nor->addr_width) {
3012                 /* already configured from SFDP */
3013         } else if (nor->info->addr_width) {
3014                 nor->addr_width = nor->info->addr_width;
3015         } else {
3016                 nor->addr_width = 3;
3017         }
3018
3019         if (nor->addr_width == 3 && nor->mtd.size > 0x1000000) {
3020                 /* enable 4-byte addressing if the device exceeds 16MiB */
3021                 nor->addr_width = 4;
3022         }
3023
3024         if (nor->addr_width > SPI_NOR_MAX_ADDR_WIDTH) {
3025                 dev_dbg(nor->dev, "address width is too large: %u\n",
3026                         nor->addr_width);
3027                 return -EINVAL;
3028         }
3029
3030         /* Set 4byte opcodes when possible. */
3031         if (nor->addr_width == 4 && nor->flags & SNOR_F_4B_OPCODES &&
3032             !(nor->flags & SNOR_F_HAS_4BAIT))
3033                 spi_nor_set_4byte_opcodes(nor);
3034
3035         return 0;
3036 }
3037
3038 static void spi_nor_debugfs_init(struct spi_nor *nor,
3039                                  const struct flash_info *info)
3040 {
3041         struct mtd_info *mtd = &nor->mtd;
3042
3043         mtd->dbg.partname = info->name;
3044         mtd->dbg.partid = devm_kasprintf(nor->dev, GFP_KERNEL, "spi-nor:%*phN",
3045                                          info->id_len, info->id);
3046 }
3047
3048 static const struct flash_info *spi_nor_get_flash_info(struct spi_nor *nor,
3049                                                        const char *name)
3050 {
3051         const struct flash_info *info = NULL;
3052
3053         if (name)
3054                 info = spi_nor_match_id(nor, name);
3055         /* Try to auto-detect if chip name wasn't specified or not found */
3056         if (!info)
3057                 info = spi_nor_read_id(nor);
3058         if (IS_ERR_OR_NULL(info))
3059                 return ERR_PTR(-ENOENT);
3060
3061         /*
3062          * If caller has specified name of flash model that can normally be
3063          * detected using JEDEC, let's verify it.
3064          */
3065         if (name && info->id_len) {
3066                 const struct flash_info *jinfo;
3067
3068                 jinfo = spi_nor_read_id(nor);
3069                 if (IS_ERR(jinfo)) {
3070                         return jinfo;
3071                 } else if (jinfo != info) {
3072                         /*
3073                          * JEDEC knows better, so overwrite platform ID. We
3074                          * can't trust partitions any longer, but we'll let
3075                          * mtd apply them anyway, since some partitions may be
3076                          * marked read-only, and we don't want to lose that
3077                          * information, even if it's not 100% accurate.
3078                          */
3079                         dev_warn(nor->dev, "found %s, expected %s\n",
3080                                  jinfo->name, info->name);
3081                         info = jinfo;
3082                 }
3083         }
3084
3085         return info;
3086 }
3087
3088 int spi_nor_scan(struct spi_nor *nor, const char *name,
3089                  const struct spi_nor_hwcaps *hwcaps)
3090 {
3091         const struct flash_info *info;
3092         struct device *dev = nor->dev;
3093         struct mtd_info *mtd = &nor->mtd;
3094         struct device_node *np = spi_nor_get_flash_node(nor);
3095         int ret;
3096         int i;
3097
3098         ret = spi_nor_check(nor);
3099         if (ret)
3100                 return ret;
3101
3102         /* Reset SPI protocol for all commands. */
3103         nor->reg_proto = SNOR_PROTO_1_1_1;
3104         nor->read_proto = SNOR_PROTO_1_1_1;
3105         nor->write_proto = SNOR_PROTO_1_1_1;
3106
3107         /*
3108          * We need the bounce buffer early to read/write registers when going
3109          * through the spi-mem layer (buffers have to be DMA-able).
3110          * For spi-mem drivers, we'll reallocate a new buffer if
3111          * nor->page_size turns out to be greater than PAGE_SIZE (which
3112          * shouldn't happen before long since NOR pages are usually less
3113          * than 1KB) after spi_nor_scan() returns.
3114          */
3115         nor->bouncebuf_size = PAGE_SIZE;
3116         nor->bouncebuf = devm_kmalloc(dev, nor->bouncebuf_size,
3117                                       GFP_KERNEL);
3118         if (!nor->bouncebuf)
3119                 return -ENOMEM;
3120
3121         info = spi_nor_get_flash_info(nor, name);
3122         if (IS_ERR(info))
3123                 return PTR_ERR(info);
3124
3125         nor->info = info;
3126
3127         spi_nor_debugfs_init(nor, info);
3128
3129         mutex_init(&nor->lock);
3130
3131         /*
3132          * Make sure the XSR_RDY flag is set before calling
3133          * spi_nor_wait_till_ready(). Xilinx S3AN share MFR
3134          * with Atmel SPI NOR.
3135          */
3136         if (info->flags & SPI_NOR_XSR_RDY)
3137                 nor->flags |=  SNOR_F_READY_XSR_RDY;
3138
3139         if (info->flags & SPI_NOR_HAS_LOCK)
3140                 nor->flags |= SNOR_F_HAS_LOCK;
3141
3142         mtd->_write = spi_nor_write;
3143
3144         /* Init flash parameters based on flash_info struct and SFDP */
3145         ret = spi_nor_init_params(nor);
3146         if (ret)
3147                 return ret;
3148
3149         if (!mtd->name)
3150                 mtd->name = dev_name(dev);
3151         mtd->priv = nor;
3152         mtd->type = MTD_NORFLASH;
3153         mtd->writesize = 1;
3154         mtd->flags = MTD_CAP_NORFLASH;
3155         mtd->size = nor->params->size;
3156         mtd->_erase = spi_nor_erase;
3157         mtd->_read = spi_nor_read;
3158         mtd->_resume = spi_nor_resume;
3159
3160         if (nor->params->locking_ops) {
3161                 mtd->_lock = spi_nor_lock;
3162                 mtd->_unlock = spi_nor_unlock;
3163                 mtd->_is_locked = spi_nor_is_locked;
3164         }
3165
3166         if (info->flags & USE_FSR)
3167                 nor->flags |= SNOR_F_USE_FSR;
3168         if (info->flags & SPI_NOR_HAS_TB) {
3169                 nor->flags |= SNOR_F_HAS_SR_TB;
3170                 if (info->flags & SPI_NOR_TB_SR_BIT6)
3171                         nor->flags |= SNOR_F_HAS_SR_TB_BIT6;
3172         }
3173
3174         if (info->flags & NO_CHIP_ERASE)
3175                 nor->flags |= SNOR_F_NO_OP_CHIP_ERASE;
3176         if (info->flags & USE_CLSR)
3177                 nor->flags |= SNOR_F_USE_CLSR;
3178
3179         if (info->flags & SPI_NOR_4BIT_BP) {
3180                 nor->flags |= SNOR_F_HAS_4BIT_BP;
3181                 if (info->flags & SPI_NOR_BP3_SR_BIT6)
3182                         nor->flags |= SNOR_F_HAS_SR_BP3_BIT6;
3183         }
3184
3185         if (info->flags & SPI_NOR_NO_ERASE)
3186                 mtd->flags |= MTD_NO_ERASE;
3187
3188         mtd->dev.parent = dev;
3189         nor->page_size = nor->params->page_size;
3190         mtd->writebufsize = nor->page_size;
3191
3192         if (of_property_read_bool(np, "broken-flash-reset"))
3193                 nor->flags |= SNOR_F_BROKEN_RESET;
3194
3195         /*
3196          * Configure the SPI memory:
3197          * - select op codes for (Fast) Read, Page Program and Sector Erase.
3198          * - set the number of dummy cycles (mode cycles + wait states).
3199          * - set the SPI protocols for register and memory accesses.
3200          */
3201         ret = spi_nor_setup(nor, hwcaps);
3202         if (ret)
3203                 return ret;
3204
3205         if (info->flags & SPI_NOR_4B_OPCODES)
3206                 nor->flags |= SNOR_F_4B_OPCODES;
3207
3208         ret = spi_nor_set_addr_width(nor);
3209         if (ret)
3210                 return ret;
3211
3212         /* Send all the required SPI flash commands to initialize device */
3213         ret = spi_nor_init(nor);
3214         if (ret)
3215                 return ret;
3216
3217         dev_info(dev, "%s (%lld Kbytes)\n", info->name,
3218                         (long long)mtd->size >> 10);
3219
3220         dev_dbg(dev,
3221                 "mtd .name = %s, .size = 0x%llx (%lldMiB), "
3222                 ".erasesize = 0x%.8x (%uKiB) .numeraseregions = %d\n",
3223                 mtd->name, (long long)mtd->size, (long long)(mtd->size >> 20),
3224                 mtd->erasesize, mtd->erasesize / 1024, mtd->numeraseregions);
3225
3226         if (mtd->numeraseregions)
3227                 for (i = 0; i < mtd->numeraseregions; i++)
3228                         dev_dbg(dev,
3229                                 "mtd.eraseregions[%d] = { .offset = 0x%llx, "
3230                                 ".erasesize = 0x%.8x (%uKiB), "
3231                                 ".numblocks = %d }\n",
3232                                 i, (long long)mtd->eraseregions[i].offset,
3233                                 mtd->eraseregions[i].erasesize,
3234                                 mtd->eraseregions[i].erasesize / 1024,
3235                                 mtd->eraseregions[i].numblocks);
3236         return 0;
3237 }
3238 EXPORT_SYMBOL_GPL(spi_nor_scan);
3239
3240 static int spi_nor_create_read_dirmap(struct spi_nor *nor)
3241 {
3242         struct spi_mem_dirmap_info info = {
3243                 .op_tmpl = SPI_MEM_OP(SPI_MEM_OP_CMD(nor->read_opcode, 1),
3244                                       SPI_MEM_OP_ADDR(nor->addr_width, 0, 1),
3245                                       SPI_MEM_OP_DUMMY(nor->read_dummy, 1),
3246                                       SPI_MEM_OP_DATA_IN(0, NULL, 1)),
3247                 .offset = 0,
3248                 .length = nor->mtd.size,
3249         };
3250         struct spi_mem_op *op = &info.op_tmpl;
3251
3252         /* get transfer protocols. */
3253         op->cmd.buswidth = spi_nor_get_protocol_inst_nbits(nor->read_proto);
3254         op->addr.buswidth = spi_nor_get_protocol_addr_nbits(nor->read_proto);
3255         op->dummy.buswidth = op->addr.buswidth;
3256         op->data.buswidth = spi_nor_get_protocol_data_nbits(nor->read_proto);
3257
3258         /* convert the dummy cycles to the number of bytes */
3259         op->dummy.nbytes = (nor->read_dummy * op->dummy.buswidth) / 8;
3260
3261         nor->dirmap.rdesc = devm_spi_mem_dirmap_create(nor->dev, nor->spimem,
3262                                                        &info);
3263         return PTR_ERR_OR_ZERO(nor->dirmap.rdesc);
3264 }
3265
3266 static int spi_nor_create_write_dirmap(struct spi_nor *nor)
3267 {
3268         struct spi_mem_dirmap_info info = {
3269                 .op_tmpl = SPI_MEM_OP(SPI_MEM_OP_CMD(nor->program_opcode, 1),
3270                                       SPI_MEM_OP_ADDR(nor->addr_width, 0, 1),
3271                                       SPI_MEM_OP_NO_DUMMY,
3272                                       SPI_MEM_OP_DATA_OUT(0, NULL, 1)),
3273                 .offset = 0,
3274                 .length = nor->mtd.size,
3275         };
3276         struct spi_mem_op *op = &info.op_tmpl;
3277
3278         /* get transfer protocols. */
3279         op->cmd.buswidth = spi_nor_get_protocol_inst_nbits(nor->write_proto);
3280         op->addr.buswidth = spi_nor_get_protocol_addr_nbits(nor->write_proto);
3281         op->dummy.buswidth = op->addr.buswidth;
3282         op->data.buswidth = spi_nor_get_protocol_data_nbits(nor->write_proto);
3283
3284         if (nor->program_opcode == SPINOR_OP_AAI_WP && nor->sst_write_second)
3285                 op->addr.nbytes = 0;
3286
3287         nor->dirmap.wdesc = devm_spi_mem_dirmap_create(nor->dev, nor->spimem,
3288                                                        &info);
3289         return PTR_ERR_OR_ZERO(nor->dirmap.wdesc);
3290 }
3291
3292 static int spi_nor_probe(struct spi_mem *spimem)
3293 {
3294         struct spi_device *spi = spimem->spi;
3295         struct flash_platform_data *data = dev_get_platdata(&spi->dev);
3296         struct spi_nor *nor;
3297         /*
3298          * Enable all caps by default. The core will mask them after
3299          * checking what's really supported using spi_mem_supports_op().
3300          */
3301         const struct spi_nor_hwcaps hwcaps = { .mask = SNOR_HWCAPS_ALL };
3302         char *flash_name;
3303         int ret;
3304
3305         nor = devm_kzalloc(&spi->dev, sizeof(*nor), GFP_KERNEL);
3306         if (!nor)
3307                 return -ENOMEM;
3308
3309         nor->spimem = spimem;
3310         nor->dev = &spi->dev;
3311         spi_nor_set_flash_node(nor, spi->dev.of_node);
3312
3313         spi_mem_set_drvdata(spimem, nor);
3314
3315         if (data && data->name)
3316                 nor->mtd.name = data->name;
3317
3318         if (!nor->mtd.name)
3319                 nor->mtd.name = spi_mem_get_name(spimem);
3320
3321         /*
3322          * For some (historical?) reason many platforms provide two different
3323          * names in flash_platform_data: "name" and "type". Quite often name is
3324          * set to "m25p80" and then "type" provides a real chip name.
3325          * If that's the case, respect "type" and ignore a "name".
3326          */
3327         if (data && data->type)
3328                 flash_name = data->type;
3329         else if (!strcmp(spi->modalias, "spi-nor"))
3330                 flash_name = NULL; /* auto-detect */
3331         else
3332                 flash_name = spi->modalias;
3333
3334         ret = spi_nor_scan(nor, flash_name, &hwcaps);
3335         if (ret)
3336                 return ret;
3337
3338         /*
3339          * None of the existing parts have > 512B pages, but let's play safe
3340          * and add this logic so that if anyone ever adds support for such
3341          * a NOR we don't end up with buffer overflows.
3342          */
3343         if (nor->page_size > PAGE_SIZE) {
3344                 nor->bouncebuf_size = nor->page_size;
3345                 devm_kfree(nor->dev, nor->bouncebuf);
3346                 nor->bouncebuf = devm_kmalloc(nor->dev,
3347                                               nor->bouncebuf_size,
3348                                               GFP_KERNEL);
3349                 if (!nor->bouncebuf)
3350                         return -ENOMEM;
3351         }
3352
3353         ret = spi_nor_create_read_dirmap(nor);
3354         if (ret)
3355                 return ret;
3356
3357         ret = spi_nor_create_write_dirmap(nor);
3358         if (ret)
3359                 return ret;
3360
3361         return mtd_device_register(&nor->mtd, data ? data->parts : NULL,
3362                                    data ? data->nr_parts : 0);
3363 }
3364
3365 static int spi_nor_remove(struct spi_mem *spimem)
3366 {
3367         struct spi_nor *nor = spi_mem_get_drvdata(spimem);
3368
3369         spi_nor_restore(nor);
3370
3371         /* Clean up MTD stuff. */
3372         return mtd_device_unregister(&nor->mtd);
3373 }
3374
3375 static void spi_nor_shutdown(struct spi_mem *spimem)
3376 {
3377         struct spi_nor *nor = spi_mem_get_drvdata(spimem);
3378
3379         spi_nor_restore(nor);
3380 }
3381
3382 /*
3383  * Do NOT add to this array without reading the following:
3384  *
3385  * Historically, many flash devices are bound to this driver by their name. But
3386  * since most of these flash are compatible to some extent, and their
3387  * differences can often be differentiated by the JEDEC read-ID command, we
3388  * encourage new users to add support to the spi-nor library, and simply bind
3389  * against a generic string here (e.g., "jedec,spi-nor").
3390  *
3391  * Many flash names are kept here in this list (as well as in spi-nor.c) to
3392  * keep them available as module aliases for existing platforms.
3393  */
3394 static const struct spi_device_id spi_nor_dev_ids[] = {
3395         /*
3396          * Allow non-DT platform devices to bind to the "spi-nor" modalias, and
3397          * hack around the fact that the SPI core does not provide uevent
3398          * matching for .of_match_table
3399          */
3400         {"spi-nor"},
3401
3402         /*
3403          * Entries not used in DTs that should be safe to drop after replacing
3404          * them with "spi-nor" in platform data.
3405          */
3406         {"s25sl064a"},  {"w25x16"},     {"m25p10"},     {"m25px64"},
3407
3408         /*
3409          * Entries that were used in DTs without "jedec,spi-nor" fallback and
3410          * should be kept for backward compatibility.
3411          */
3412         {"at25df321a"}, {"at25df641"},  {"at26df081a"},
3413         {"mx25l4005a"}, {"mx25l1606e"}, {"mx25l6405d"}, {"mx25l12805d"},
3414         {"mx25l25635e"},{"mx66l51235l"},
3415         {"n25q064"},    {"n25q128a11"}, {"n25q128a13"}, {"n25q512a"},
3416         {"s25fl256s1"}, {"s25fl512s"},  {"s25sl12801"}, {"s25fl008k"},
3417         {"s25fl064k"},
3418         {"sst25vf040b"},{"sst25vf016b"},{"sst25vf032b"},{"sst25wf040"},
3419         {"m25p40"},     {"m25p80"},     {"m25p16"},     {"m25p32"},
3420         {"m25p64"},     {"m25p128"},
3421         {"w25x80"},     {"w25x32"},     {"w25q32"},     {"w25q32dw"},
3422         {"w25q80bl"},   {"w25q128"},    {"w25q256"},
3423
3424         /* Flashes that can't be detected using JEDEC */
3425         {"m25p05-nonjedec"},    {"m25p10-nonjedec"},    {"m25p20-nonjedec"},
3426         {"m25p40-nonjedec"},    {"m25p80-nonjedec"},    {"m25p16-nonjedec"},
3427         {"m25p32-nonjedec"},    {"m25p64-nonjedec"},    {"m25p128-nonjedec"},
3428
3429         /* Everspin MRAMs (non-JEDEC) */
3430         { "mr25h128" }, /* 128 Kib, 40 MHz */
3431         { "mr25h256" }, /* 256 Kib, 40 MHz */
3432         { "mr25h10" },  /*   1 Mib, 40 MHz */
3433         { "mr25h40" },  /*   4 Mib, 40 MHz */
3434
3435         { },
3436 };
3437 MODULE_DEVICE_TABLE(spi, spi_nor_dev_ids);
3438
3439 static const struct of_device_id spi_nor_of_table[] = {
3440         /*
3441          * Generic compatibility for SPI NOR that can be identified by the
3442          * JEDEC READ ID opcode (0x9F). Use this, if possible.
3443          */
3444         { .compatible = "jedec,spi-nor" },
3445         { /* sentinel */ },
3446 };
3447 MODULE_DEVICE_TABLE(of, spi_nor_of_table);
3448
3449 /*
3450  * REVISIT: many of these chips have deep power-down modes, which
3451  * should clearly be entered on suspend() to minimize power use.
3452  * And also when they're otherwise idle...
3453  */
3454 static struct spi_mem_driver spi_nor_driver = {
3455         .spidrv = {
3456                 .driver = {
3457                         .name = "spi-nor",
3458                         .of_match_table = spi_nor_of_table,
3459                 },
3460                 .id_table = spi_nor_dev_ids,
3461         },
3462         .probe = spi_nor_probe,
3463         .remove = spi_nor_remove,
3464         .shutdown = spi_nor_shutdown,
3465 };
3466 module_spi_mem_driver(spi_nor_driver);
3467
3468 MODULE_LICENSE("GPL v2");
3469 MODULE_AUTHOR("Huang Shijie <shijie8@gmail.com>");
3470 MODULE_AUTHOR("Mike Lavender");
3471 MODULE_DESCRIPTION("framework for SPI NOR");