drivers/mtd/spi-nor/spi-nor.c

   1 /*
   2  * Based on m25p80.c, by Mike Lavender (mike@steroidmicros.com), with
   3  * influence from lart.c (Abraham Van Der Merwe) and mtd_dataflash.c
   4  *
   5  * Copyright (C) 2005, Intec Automation Inc.
   6  * Copyright (C) 2014, Freescale Semiconductor, Inc.
   7  *
   8  * This code is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  */
  12
  13 #include <linux/err.h>
  14 #include <linux/errno.h>
  15 #include <linux/module.h>
  16 #include <linux/device.h>
  17 #include <linux/mutex.h>
  18 #include <linux/math64.h>
  19 #include <linux/sizes.h>
  20 #include <linux/slab.h>
  21 #include <linux/sort.h>
  22
  23 #include <linux/mtd/mtd.h>
  24 #include <linux/of_platform.h>
  25 #include <linux/spi/flash.h>
  26 #include <linux/mtd/spi-nor.h>
  27
  28 /* Define max times to check status register before we give up. */
  29
  30 /*
  31  * For everything but full-chip erase; probably could be much smaller, but kept
  32  * around for safety for now
  33  */
  34 #define DEFAULT_READY_WAIT_JIFFIES              (40UL * HZ)
  35
  36 /*
  37  * For full-chip erase, calibrated to a 2MB flash (M25P16); should be scaled up
  38  * for larger flash
  39  */
  40 #define CHIP_ERASE_2MB_READY_WAIT_JIFFIES       (40UL * HZ)
  41
  42 #define SPI_NOR_MAX_ID_LEN      6
  43 #define SPI_NOR_MAX_ADDR_WIDTH  4
  44
  45 struct flash_info {
  46         char            *name;
  47
  48         /*
  49          * This array stores the ID bytes.
  50          * The first three bytes are the JEDIC ID.
  51          * JEDEC ID zero means "no ID" (mostly older chips).
  52          */
  53         u8              id[SPI_NOR_MAX_ID_LEN];
  54         u8              id_len;
  55
  56         /* The size listed here is what works with SPINOR_OP_SE, which isn't
  57          * necessarily called a "sector" by the vendor.
  58          */
  59         unsigned        sector_size;
  60         u16             n_sectors;
  61
  62         u16             page_size;
  63         u16             addr_width;
  64
  65         u16             flags;
  66 #define SECT_4K                 BIT(0)  /* SPINOR_OP_BE_4K works uniformly */
  67 #define SPI_NOR_NO_ERASE        BIT(1)  /* No erase command needed */
  68 #define SST_WRITE               BIT(2)  /* use SST byte programming */
  69 #define SPI_NOR_NO_FR           BIT(3)  /* Can't do fastread */
  70 #define SECT_4K_PMC             BIT(4)  /* SPINOR_OP_BE_4K_PMC works uniformly */
  71 #define SPI_NOR_DUAL_READ       BIT(5)  /* Flash supports Dual Read */
  72 #define SPI_NOR_QUAD_READ       BIT(6)  /* Flash supports Quad Read */
  73 #define USE_FSR                 BIT(7)  /* use flag status register */
  74 #define SPI_NOR_HAS_LOCK        BIT(8)  /* Flash supports lock/unlock via SR */
  75 #define SPI_NOR_HAS_TB          BIT(9)  /*
  76                                          * Flash SR has Top/Bottom (TB) protect
  77                                          * bit. Must be used with
  78                                          * SPI_NOR_HAS_LOCK.
  79                                          */
  80 #define SPI_S3AN                BIT(10) /*
  81                                          * Xilinx Spartan 3AN In-System Flash
  82                                          * (MFR cannot be used for probing
  83                                          * because it has the same value as
  84                                          * ATMEL flashes)
  85                                          */
  86 #define SPI_NOR_4B_OPCODES      BIT(11) /*
  87                                          * Use dedicated 4byte address op codes
  88                                          * to support memory size above 128Mib.
  89                                          */
  90 #define NO_CHIP_ERASE           BIT(12) /* Chip does not support chip erase */
  91 #define SPI_NOR_SKIP_SFDP       BIT(13) /* Skip parsing of SFDP tables */
  92 #define USE_CLSR                BIT(14) /* use CLSR command */
  93
  94         int     (*quad_enable)(struct spi_nor *nor);
  95 };
  96
  97 #define JEDEC_MFR(info) ((info)->id[0])
  98
  99 static const struct flash_info *spi_nor_match_id(const char *name);
 100
 101 /*
 102  * Read the status register, returning its value in the location
 103  * Return the status register value.
 104  * Returns negative if error occurred.
 105  */
 106 static int read_sr(struct spi_nor *nor)
 107 {
 108         int ret;
 109         u8 val;
 110
 111         ret = nor->read_reg(nor, SPINOR_OP_RDSR, &val, 1);
 112         if (ret < 0) {
 113                 pr_err("error %d reading SR\n", (int) ret);
 114                 return ret;
 115         }
 116
 117         return val;
 118 }
 119
 120 /*
 121  * Read the flag status register, returning its value in the location
 122  * Return the status register value.
 123  * Returns negative if error occurred.
 124  */
 125 static int read_fsr(struct spi_nor *nor)
 126 {
 127         int ret;
 128         u8 val;
 129
 130         ret = nor->read_reg(nor, SPINOR_OP_RDFSR, &val, 1);
 131         if (ret < 0) {
 132                 pr_err("error %d reading FSR\n", ret);
 133                 return ret;
 134         }
 135
 136         return val;
 137 }
 138
 139 /*
 140  * Read configuration register, returning its value in the
 141  * location. Return the configuration register value.
 142  * Returns negative if error occurred.
 143  */
 144 static int read_cr(struct spi_nor *nor)
 145 {
 146         int ret;
 147         u8 val;
 148
 149         ret = nor->read_reg(nor, SPINOR_OP_RDCR, &val, 1);
 150         if (ret < 0) {
 151                 dev_err(nor->dev, "error %d reading CR\n", ret);
 152                 return ret;
 153         }
 154
 155         return val;
 156 }
 157
 158 /*
 159  * Write status register 1 byte
 160  * Returns negative if error occurred.
 161  */
 162 static inline int write_sr(struct spi_nor *nor, u8 val)
 163 {
 164         nor->cmd_buf[0] = val;
 165         return nor->write_reg(nor, SPINOR_OP_WRSR, nor->cmd_buf, 1);
 166 }
 167
 168 /*
 169  * Set write enable latch with Write Enable command.
 170  * Returns negative if error occurred.
 171  */
 172 static inline int write_enable(struct spi_nor *nor)
 173 {
 174         return nor->write_reg(nor, SPINOR_OP_WREN, NULL, 0);
 175 }
 176
 177 /*
 178  * Send write disable instruction to the chip.
 179  */
 180 static inline int write_disable(struct spi_nor *nor)
 181 {
 182         return nor->write_reg(nor, SPINOR_OP_WRDI, NULL, 0);
 183 }
 184
 185 static inline struct spi_nor *mtd_to_spi_nor(struct mtd_info *mtd)
 186 {
 187         return mtd->priv;
 188 }
 189
 190
 191 static u8 spi_nor_convert_opcode(u8 opcode, const u8 table[][2], size_t size)
 192 {
 193         size_t i;
 194
 195         for (i = 0; i < size; i++)
 196                 if (table[i][0] == opcode)
 197                         return table[i][1];
 198
 199         /* No conversion found, keep input op code. */
 200         return opcode;
 201 }
 202
 203 static inline u8 spi_nor_convert_3to4_read(u8 opcode)
 204 {
 205         static const u8 spi_nor_3to4_read[][2] = {
 206                 { SPINOR_OP_READ,       SPINOR_OP_READ_4B },
 207                 { SPINOR_OP_READ_FAST,  SPINOR_OP_READ_FAST_4B },
 208                 { SPINOR_OP_READ_1_1_2, SPINOR_OP_READ_1_1_2_4B },
 209                 { SPINOR_OP_READ_1_2_2, SPINOR_OP_READ_1_2_2_4B },
 210                 { SPINOR_OP_READ_1_1_4, SPINOR_OP_READ_1_1_4_4B },
 211                 { SPINOR_OP_READ_1_4_4, SPINOR_OP_READ_1_4_4_4B },
 212
 213                 { SPINOR_OP_READ_1_1_1_DTR,     SPINOR_OP_READ_1_1_1_DTR_4B },
 214                 { SPINOR_OP_READ_1_2_2_DTR,     SPINOR_OP_READ_1_2_2_DTR_4B },
 215                 { SPINOR_OP_READ_1_4_4_DTR,     SPINOR_OP_READ_1_4_4_DTR_4B },
 216         };
 217
 218         return spi_nor_convert_opcode(opcode, spi_nor_3to4_read,
 219                                       ARRAY_SIZE(spi_nor_3to4_read));
 220 }
 221
 222 static inline u8 spi_nor_convert_3to4_program(u8 opcode)
 223 {
 224         static const u8 spi_nor_3to4_program[][2] = {
 225                 { SPINOR_OP_PP,         SPINOR_OP_PP_4B },
 226                 { SPINOR_OP_PP_1_1_4,   SPINOR_OP_PP_1_1_4_4B },
 227                 { SPINOR_OP_PP_1_4_4,   SPINOR_OP_PP_1_4_4_4B },
 228         };
 229
 230         return spi_nor_convert_opcode(opcode, spi_nor_3to4_program,
 231                                       ARRAY_SIZE(spi_nor_3to4_program));
 232 }
 233
 234 static inline u8 spi_nor_convert_3to4_erase(u8 opcode)
 235 {
 236         static const u8 spi_nor_3to4_erase[][2] = {
 237                 { SPINOR_OP_BE_4K,      SPINOR_OP_BE_4K_4B },
 238                 { SPINOR_OP_BE_32K,     SPINOR_OP_BE_32K_4B },
 239                 { SPINOR_OP_SE,         SPINOR_OP_SE_4B },
 240         };
 241
 242         return spi_nor_convert_opcode(opcode, spi_nor_3to4_erase,
 243                                       ARRAY_SIZE(spi_nor_3to4_erase));
 244 }
 245
 246 static void spi_nor_set_4byte_opcodes(struct spi_nor *nor,
 247                                       const struct flash_info *info)
 248 {
 249         /* Do some manufacturer fixups first */
 250         switch (JEDEC_MFR(info)) {
 251         case SNOR_MFR_SPANSION:
 252                 /* No small sector erase for 4-byte command set */
 253                 nor->erase_opcode = SPINOR_OP_SE;
 254                 nor->mtd.erasesize = info->sector_size;
 255                 break;
 256
 257         default:
 258                 break;
 259         }
 260
 261         nor->read_opcode = spi_nor_convert_3to4_read(nor->read_opcode);
 262         nor->program_opcode = spi_nor_convert_3to4_program(nor->program_opcode);
 263         nor->erase_opcode = spi_nor_convert_3to4_erase(nor->erase_opcode);
 264
 265         if (!spi_nor_has_uniform_erase(nor)) {
 266                 struct spi_nor_erase_map *map = &nor->erase_map;
 267                 struct spi_nor_erase_type *erase;
 268                 int i;
 269
 270                 for (i = 0; i < SNOR_ERASE_TYPE_MAX; i++) {
 271                         erase = &map->erase_type[i];
 272                         erase->opcode =
 273                                 spi_nor_convert_3to4_erase(erase->opcode);
 274                 }
 275         }
 276 }
 277
 278 /* Enable/disable 4-byte addressing mode. */
 279 static inline int set_4byte(struct spi_nor *nor, const struct flash_info *info,
 280                             int enable)
 281 {
 282         int status;
 283         bool need_wren = false;
 284         u8 cmd;
 285
 286         switch (JEDEC_MFR(info)) {
 287         case SNOR_MFR_MICRON:
 288                 /* Some Micron need WREN command; all will accept it */
 289                 need_wren = true;
 290         case SNOR_MFR_MACRONIX:
 291         case SNOR_MFR_WINBOND:
 292                 if (need_wren)
 293                         write_enable(nor);
 294
 295                 cmd = enable ? SPINOR_OP_EN4B : SPINOR_OP_EX4B;
 296                 status = nor->write_reg(nor, cmd, NULL, 0);
 297                 if (need_wren)
 298                         write_disable(nor);
 299
 300                 if (!status && !enable &&
 301                     JEDEC_MFR(info) == SNOR_MFR_WINBOND) {
 302                         /*
 303                          * On Winbond W25Q256FV, leaving 4byte mode causes
 304                          * the Extended Address Register to be set to 1, so all
 305                          * 3-byte-address reads come from the second 16M.
 306                          * We must clear the register to enable normal behavior.
 307                          */
 308                         write_enable(nor);
 309                         nor->cmd_buf[0] = 0;
 310                         nor->write_reg(nor, SPINOR_OP_WREAR, nor->cmd_buf, 1);
 311                         write_disable(nor);
 312                 }
 313
 314                 return status;
 315         default:
 316                 /* Spansion style */
 317                 nor->cmd_buf[0] = enable << 7;
 318                 return nor->write_reg(nor, SPINOR_OP_BRWR, nor->cmd_buf, 1);
 319         }
 320 }
 321
 322 static int s3an_sr_ready(struct spi_nor *nor)
 323 {
 324         int ret;
 325         u8 val;
 326
 327         ret = nor->read_reg(nor, SPINOR_OP_XRDSR, &val, 1);
 328         if (ret < 0) {
 329                 dev_err(nor->dev, "error %d reading XRDSR\n", (int) ret);
 330                 return ret;
 331         }
 332
 333         return !!(val & XSR_RDY);
 334 }
 335
 336 static inline int spi_nor_sr_ready(struct spi_nor *nor)
 337 {
 338         int sr = read_sr(nor);
 339         if (sr < 0)
 340                 return sr;
 341
 342         if (nor->flags & SNOR_F_USE_CLSR && sr & (SR_E_ERR | SR_P_ERR)) {
 343                 if (sr & SR_E_ERR)
 344                         dev_err(nor->dev, "Erase Error occurred\n");
 345                 else
 346                         dev_err(nor->dev, "Programming Error occurred\n");
 347
 348                 nor->write_reg(nor, SPINOR_OP_CLSR, NULL, 0);
 349                 return -EIO;
 350         }
 351
 352         return !(sr & SR_WIP);
 353 }
 354
 355 static inline int spi_nor_fsr_ready(struct spi_nor *nor)
 356 {
 357         int fsr = read_fsr(nor);
 358         if (fsr < 0)
 359                 return fsr;
 360
 361         if (fsr & (FSR_E_ERR | FSR_P_ERR)) {
 362                 if (fsr & FSR_E_ERR)
 363                         dev_err(nor->dev, "Erase operation failed.\n");
 364                 else
 365                         dev_err(nor->dev, "Program operation failed.\n");
 366
 367                 if (fsr & FSR_PT_ERR)
 368                         dev_err(nor->dev,
 369                         "Attempted to modify a protected sector.\n");
 370
 371                 nor->write_reg(nor, SPINOR_OP_CLFSR, NULL, 0);
 372                 return -EIO;
 373         }
 374
 375         return fsr & FSR_READY;
 376 }
 377
 378 static int spi_nor_ready(struct spi_nor *nor)
 379 {
 380         int sr, fsr;
 381
 382         if (nor->flags & SNOR_F_READY_XSR_RDY)
 383                 sr = s3an_sr_ready(nor);
 384         else
 385                 sr = spi_nor_sr_ready(nor);
 386         if (sr < 0)
 387                 return sr;
 388         fsr = nor->flags & SNOR_F_USE_FSR ? spi_nor_fsr_ready(nor) : 1;
 389         if (fsr < 0)
 390                 return fsr;
 391         return sr && fsr;
 392 }
 393
 394 /*
 395  * Service routine to read status register until ready, or timeout occurs.
 396  * Returns non-zero if error.
 397  */
 398 static int spi_nor_wait_till_ready_with_timeout(struct spi_nor *nor,
 399                                                 unsigned long timeout_jiffies)
 400 {
 401         unsigned long deadline;
 402         int timeout = 0, ret;
 403
 404         deadline = jiffies + timeout_jiffies;
 405
 406         while (!timeout) {
 407                 if (time_after_eq(jiffies, deadline))
 408                         timeout = 1;
 409
 410                 ret = spi_nor_ready(nor);
 411                 if (ret < 0)
 412                         return ret;
 413                 if (ret)
 414                         return 0;
 415
 416                 cond_resched();
 417         }
 418
 419         dev_err(nor->dev, "flash operation timed out\n");
 420
 421         return -ETIMEDOUT;
 422 }
 423
 424 static int spi_nor_wait_till_ready(struct spi_nor *nor)
 425 {
 426         return spi_nor_wait_till_ready_with_timeout(nor,
 427                                                     DEFAULT_READY_WAIT_JIFFIES);
 428 }
 429
 430 /*
 431  * Erase the whole flash memory
 432  *
 433  * Returns 0 if successful, non-zero otherwise.
 434  */
 435 static int erase_chip(struct spi_nor *nor)
 436 {
 437         dev_dbg(nor->dev, " %lldKiB\n", (long long)(nor->mtd.size >> 10));
 438
 439         return nor->write_reg(nor, SPINOR_OP_CHIP_ERASE, NULL, 0);
 440 }
 441
 442 static int spi_nor_lock_and_prep(struct spi_nor *nor, enum spi_nor_ops ops)
 443 {
 444         int ret = 0;
 445
 446         mutex_lock(&nor->lock);
 447
 448         if (nor->prepare) {
 449                 ret = nor->prepare(nor, ops);
 450                 if (ret) {
 451                         dev_err(nor->dev, "failed in the preparation.\n");
 452                         mutex_unlock(&nor->lock);
 453                         return ret;
 454                 }
 455         }
 456         return ret;
 457 }
 458
 459 static void spi_nor_unlock_and_unprep(struct spi_nor *nor, enum spi_nor_ops ops)
 460 {
 461         if (nor->unprepare)
 462                 nor->unprepare(nor, ops);
 463         mutex_unlock(&nor->lock);
 464 }
 465
 466 /*
 467  * This code converts an address to the Default Address Mode, that has non
 468  * power of two page sizes. We must support this mode because it is the default
 469  * mode supported by Xilinx tools, it can access the whole flash area and
 470  * changing over to the Power-of-two mode is irreversible and corrupts the
 471  * original data.
 472  * Addr can safely be unsigned int, the biggest S3AN device is smaller than
 473  * 4 MiB.
 474  */
 475 static loff_t spi_nor_s3an_addr_convert(struct spi_nor *nor, unsigned int addr)
 476 {
 477         unsigned int offset;
 478         unsigned int page;
 479
 480         offset = addr % nor->page_size;
 481         page = addr / nor->page_size;
 482         page <<= (nor->page_size > 512) ? 10 : 9;
 483
 484         return page | offset;
 485 }
 486
 487 /*
 488  * Initiate the erasure of a single sector
 489  */
 490 static int spi_nor_erase_sector(struct spi_nor *nor, u32 addr)
 491 {
 492         u8 buf[SPI_NOR_MAX_ADDR_WIDTH];
 493         int i;
 494
 495         if (nor->flags & SNOR_F_S3AN_ADDR_DEFAULT)
 496                 addr = spi_nor_s3an_addr_convert(nor, addr);
 497
 498         if (nor->erase)
 499                 return nor->erase(nor, addr);
 500
 501         /*
 502          * Default implementation, if driver doesn't have a specialized HW
 503          * control
 504          */
 505         for (i = nor->addr_width - 1; i >= 0; i--) {
 506                 buf[i] = addr & 0xff;
 507                 addr >>= 8;
 508         }
 509
 510         return nor->write_reg(nor, nor->erase_opcode, buf, nor->addr_width);
 511 }
 512
 513 /**
 514  * spi_nor_div_by_erase_size() - calculate remainder and update new dividend
 515  * @erase:      pointer to a structure that describes a SPI NOR erase type
 516  * @dividend:   dividend value
 517  * @remainder:  pointer to u32 remainder (will be updated)
 518  *
 519  * Return: the result of the division
 520  */
 521 static u64 spi_nor_div_by_erase_size(const struct spi_nor_erase_type *erase,
 522                                      u64 dividend, u32 *remainder)
 523 {
 524         /* JEDEC JESD216B Standard imposes erase sizes to be power of 2. */
 525         *remainder = (u32)dividend & erase->size_mask;
 526         return dividend >> erase->size_shift;
 527 }
 528
 529 /**
 530  * spi_nor_find_best_erase_type() - find the best erase type for the given
 531  *                                  offset in the serial flash memory and the
 532  *                                  number of bytes to erase. The region in
 533  *                                  which the address fits is expected to be
 534  *                                  provided.
 535  * @map:        the erase map of the SPI NOR
 536  * @region:     pointer to a structure that describes a SPI NOR erase region
 537  * @addr:       offset in the serial flash memory
 538  * @len:        number of bytes to erase
 539  *
 540  * Return: a pointer to the best fitted erase type, NULL otherwise.
 541  */
 542 static const struct spi_nor_erase_type *
 543 spi_nor_find_best_erase_type(const struct spi_nor_erase_map *map,
 544                              const struct spi_nor_erase_region *region,
 545                              u64 addr, u32 len)
 546 {
 547         const struct spi_nor_erase_type *erase;
 548         u32 rem;
 549         int i;
 550         u8 erase_mask = region->offset & SNOR_ERASE_TYPE_MASK;
 551
 552         /*
 553          * Erase types are ordered by size, with the biggest erase type at
 554          * index 0.
 555          */
 556         for (i = SNOR_ERASE_TYPE_MAX - 1; i >= 0; i--) {
 557                 /* Does the erase region support the tested erase type? */
 558                 if (!(erase_mask & BIT(i)))
 559                         continue;
 560
 561                 erase = &map->erase_type[i];
 562
 563                 /* Don't erase more than what the user has asked for. */
 564                 if (erase->size > len)
 565                         continue;
 566
 567                 /* Alignment is not mandatory for overlaid regions */
 568                 if (region->offset & SNOR_OVERLAID_REGION)
 569                         return erase;
 570
 571                 spi_nor_div_by_erase_size(erase, addr, &rem);
 572                 if (rem)
 573                         continue;
 574                 else
 575                         return erase;
 576         }
 577
 578         return NULL;
 579 }
 580
 581 /**
 582  * spi_nor_region_next() - get the next spi nor region
 583  * @region:     pointer to a structure that describes a SPI NOR erase region
 584  *
 585  * Return: the next spi nor region or NULL if last region.
 586  */
 587 static struct spi_nor_erase_region *
 588 spi_nor_region_next(struct spi_nor_erase_region *region)
 589 {
 590         if (spi_nor_region_is_last(region))
 591                 return NULL;
 592         region++;
 593         return region;
 594 }
 595
 596 /**
 597  * spi_nor_find_erase_region() - find the region of the serial flash memory in
 598  *                               which the offset fits
 599  * @map:        the erase map of the SPI NOR
 600  * @addr:       offset in the serial flash memory
 601  *
 602  * Return: a pointer to the spi_nor_erase_region struct, ERR_PTR(-errno)
 603  *         otherwise.
 604  */
 605 static struct spi_nor_erase_region *
 606 spi_nor_find_erase_region(const struct spi_nor_erase_map *map, u64 addr)
 607 {
 608         struct spi_nor_erase_region *region = map->regions;
 609         u64 region_start = region->offset & ~SNOR_ERASE_FLAGS_MASK;
 610         u64 region_end = region_start + region->size;
 611
 612         while (addr < region_start || addr >= region_end) {
 613                 region = spi_nor_region_next(region);
 614                 if (!region)
 615                         return ERR_PTR(-EINVAL);
 616
 617                 region_start = region->offset & ~SNOR_ERASE_FLAGS_MASK;
 618                 region_end = region_start + region->size;
 619         }
 620
 621         return region;
 622 }
 623
 624 /**
 625  * spi_nor_init_erase_cmd() - initialize an erase command
 626  * @region:     pointer to a structure that describes a SPI NOR erase region
 627  * @erase:      pointer to a structure that describes a SPI NOR erase type
 628  *
 629  * Return: the pointer to the allocated erase command, ERR_PTR(-errno)
 630  *         otherwise.
 631  */
 632 static struct spi_nor_erase_command *
 633 spi_nor_init_erase_cmd(const struct spi_nor_erase_region *region,
 634                        const struct spi_nor_erase_type *erase)
 635 {
 636         struct spi_nor_erase_command *cmd;
 637
 638         cmd = kmalloc(sizeof(*cmd), GFP_KERNEL);
 639         if (!cmd)
 640                 return ERR_PTR(-ENOMEM);
 641
 642         INIT_LIST_HEAD(&cmd->list);
 643         cmd->opcode = erase->opcode;
 644         cmd->count = 1;
 645
 646         if (region->offset & SNOR_OVERLAID_REGION)
 647                 cmd->size = region->size;
 648         else
 649                 cmd->size = erase->size;
 650
 651         return cmd;
 652 }
 653
 654 /**
 655  * spi_nor_destroy_erase_cmd_list() - destroy erase command list
 656  * @erase_list: list of erase commands
 657  */
 658 static void spi_nor_destroy_erase_cmd_list(struct list_head *erase_list)
 659 {
 660         struct spi_nor_erase_command *cmd, *next;
 661
 662         list_for_each_entry_safe(cmd, next, erase_list, list) {
 663                 list_del(&cmd->list);
 664                 kfree(cmd);
 665         }
 666 }
 667
 668 /**
 669  * spi_nor_init_erase_cmd_list() - initialize erase command list
 670  * @nor:        pointer to a 'struct spi_nor'
 671  * @erase_list: list of erase commands to be executed once we validate that the
 672  *              erase can be performed
 673  * @addr:       offset in the serial flash memory
 674  * @len:        number of bytes to erase
 675  *
 676  * Builds the list of best fitted erase commands and verifies if the erase can
 677  * be performed.
 678  *
 679  * Return: 0 on success, -errno otherwise.
 680  */
 681 static int spi_nor_init_erase_cmd_list(struct spi_nor *nor,
 682                                        struct list_head *erase_list,
 683                                        u64 addr, u32 len)
 684 {
 685         const struct spi_nor_erase_map *map = &nor->erase_map;
 686         const struct spi_nor_erase_type *erase, *prev_erase = NULL;
 687         struct spi_nor_erase_region *region;
 688         struct spi_nor_erase_command *cmd = NULL;
 689         u64 region_end;
 690         int ret = -EINVAL;
 691
 692         region = spi_nor_find_erase_region(map, addr);
 693         if (IS_ERR(region))
 694                 return PTR_ERR(region);
 695
 696         region_end = spi_nor_region_end(region);
 697
 698         while (len) {
 699                 erase = spi_nor_find_best_erase_type(map, region, addr, len);
 700                 if (!erase)
 701                         goto destroy_erase_cmd_list;
 702
 703                 if (prev_erase != erase ||
 704                     region->offset & SNOR_OVERLAID_REGION) {
 705                         cmd = spi_nor_init_erase_cmd(region, erase);
 706                         if (IS_ERR(cmd)) {
 707                                 ret = PTR_ERR(cmd);
 708                                 goto destroy_erase_cmd_list;
 709                         }
 710
 711                         list_add_tail(&cmd->list, erase_list);
 712                 } else {
 713                         cmd->count++;
 714                 }
 715
 716                 addr += cmd->size;
 717                 len -= cmd->size;
 718
 719                 if (len && addr >= region_end) {
 720                         region = spi_nor_region_next(region);
 721                         if (!region)
 722                                 goto destroy_erase_cmd_list;
 723                         region_end = spi_nor_region_end(region);
 724                 }
 725
 726                 prev_erase = erase;
 727         }
 728
 729         return 0;
 730
 731 destroy_erase_cmd_list:
 732         spi_nor_destroy_erase_cmd_list(erase_list);
 733         return ret;
 734 }
 735
 736 /**
 737  * spi_nor_erase_multi_sectors() - perform a non-uniform erase
 738  * @nor:        pointer to a 'struct spi_nor'
 739  * @addr:       offset in the serial flash memory
 740  * @len:        number of bytes to erase
 741  *
 742  * Build a list of best fitted erase commands and execute it once we validate
 743  * that the erase can be performed.
 744  *
 745  * Return: 0 on success, -errno otherwise.
 746  */
 747 static int spi_nor_erase_multi_sectors(struct spi_nor *nor, u64 addr, u32 len)
 748 {
 749         LIST_HEAD(erase_list);
 750         struct spi_nor_erase_command *cmd, *next;
 751         int ret;
 752
 753         ret = spi_nor_init_erase_cmd_list(nor, &erase_list, addr, len);
 754         if (ret)
 755                 return ret;
 756
 757         list_for_each_entry_safe(cmd, next, &erase_list, list) {
 758                 nor->erase_opcode = cmd->opcode;
 759                 while (cmd->count) {
 760                         write_enable(nor);
 761
 762                         ret = spi_nor_erase_sector(nor, addr);
 763                         if (ret)
 764                                 goto destroy_erase_cmd_list;
 765
 766                         addr += cmd->size;
 767                         cmd->count--;
 768
 769                         ret = spi_nor_wait_till_ready(nor);
 770                         if (ret)
 771                                 goto destroy_erase_cmd_list;
 772                 }
 773                 list_del(&cmd->list);
 774                 kfree(cmd);
 775         }
 776
 777         return 0;
 778
 779 destroy_erase_cmd_list:
 780         spi_nor_destroy_erase_cmd_list(&erase_list);
 781         return ret;
 782 }
 783
 784 /*
 785  * Erase an address range on the nor chip.  The address range may extend
 786  * one or more erase sectors.  Return an error is there is a problem erasing.
 787  */
 788 static int spi_nor_erase(struct mtd_info *mtd, struct erase_info *instr)
 789 {
 790         struct spi_nor *nor = mtd_to_spi_nor(mtd);
 791         u32 addr, len;
 792         uint32_t rem;
 793         int ret;
 794
 795         dev_dbg(nor->dev, "at 0x%llx, len %lld\n", (long long)instr->addr,
 796                         (long long)instr->len);
 797
 798         if (spi_nor_has_uniform_erase(nor)) {
 799                 div_u64_rem(instr->len, mtd->erasesize, &rem);
 800                 if (rem)
 801                         return -EINVAL;
 802         }
 803
 804         addr = instr->addr;
 805         len = instr->len;
 806
 807         ret = spi_nor_lock_and_prep(nor, SPI_NOR_OPS_ERASE);
 808         if (ret)
 809                 return ret;
 810
 811         /* whole-chip erase? */
 812         if (len == mtd->size && !(nor->flags & SNOR_F_NO_OP_CHIP_ERASE)) {
 813                 unsigned long timeout;
 814
 815                 write_enable(nor);
 816
 817                 if (erase_chip(nor)) {
 818                         ret = -EIO;
 819                         goto erase_err;
 820                 }
 821
 822                 /*
 823                  * Scale the timeout linearly with the size of the flash, with
 824                  * a minimum calibrated to an old 2MB flash. We could try to
 825                  * pull these from CFI/SFDP, but these values should be good
 826                  * enough for now.
 827                  */
 828                 timeout = max(CHIP_ERASE_2MB_READY_WAIT_JIFFIES,
 829                               CHIP_ERASE_2MB_READY_WAIT_JIFFIES *
 830                               (unsigned long)(mtd->size / SZ_2M));
 831                 ret = spi_nor_wait_till_ready_with_timeout(nor, timeout);
 832                 if (ret)
 833                         goto erase_err;
 834
 835         /* REVISIT in some cases we could speed up erasing large regions
 836          * by using SPINOR_OP_SE instead of SPINOR_OP_BE_4K.  We may have set up
 837          * to use "small sector erase", but that's not always optimal.
 838          */
 839
 840         /* "sector"-at-a-time erase */
 841         } else if (spi_nor_has_uniform_erase(nor)) {
 842                 while (len) {
 843                         write_enable(nor);
 844
 845                         ret = spi_nor_erase_sector(nor, addr);
 846                         if (ret)
 847                                 goto erase_err;
 848
 849                         addr += mtd->erasesize;
 850                         len -= mtd->erasesize;
 851
 852                         ret = spi_nor_wait_till_ready(nor);
 853                         if (ret)
 854                                 goto erase_err;
 855                 }
 856
 857         /* erase multiple sectors */
 858         } else {
 859                 ret = spi_nor_erase_multi_sectors(nor, addr, len);
 860                 if (ret)
 861                         goto erase_err;
 862         }
 863
 864         write_disable(nor);
 865
 866 erase_err:
 867         spi_nor_unlock_and_unprep(nor, SPI_NOR_OPS_ERASE);
 868
 869         return ret;
 870 }
 871
 872 /* Write status register and ensure bits in mask match written values */
 873 static int write_sr_and_check(struct spi_nor *nor, u8 status_new, u8 mask)
 874 {
 875         int ret;
 876
 877         write_enable(nor);
 878         ret = write_sr(nor, status_new);
 879         if (ret)
 880                 return ret;
 881
 882         ret = spi_nor_wait_till_ready(nor);
 883         if (ret)
 884                 return ret;
 885
 886         ret = read_sr(nor);
 887         if (ret < 0)
 888                 return ret;
 889
 890         return ((ret & mask) != (status_new & mask)) ? -EIO : 0;
 891 }
 892
 893 static void stm_get_locked_range(struct spi_nor *nor, u8 sr, loff_t *ofs,
 894                                  uint64_t *len)
 895 {
 896         struct mtd_info *mtd = &nor->mtd;
 897         u8 mask = SR_BP2 | SR_BP1 | SR_BP0;
 898         int shift = ffs(mask) - 1;
 899         int pow;
 900
 901         if (!(sr & mask)) {
 902                 /* No protection */
 903                 *ofs = 0;
 904                 *len = 0;
 905         } else {
 906                 pow = ((sr & mask) ^ mask) >> shift;
 907                 *len = mtd->size >> pow;
 908                 if (nor->flags & SNOR_F_HAS_SR_TB && sr & SR_TB)
 909                         *ofs = 0;
 910                 else
 911                         *ofs = mtd->size - *len;
 912         }
 913 }
 914
 915 /*
 916  * Return 1 if the entire region is locked (if @locked is true) or unlocked (if
 917  * @locked is false); 0 otherwise
 918  */
 919 static int stm_check_lock_status_sr(struct spi_nor *nor, loff_t ofs, uint64_t len,
 920                                     u8 sr, bool locked)
 921 {
 922         loff_t lock_offs;
 923         uint64_t lock_len;
 924
 925         if (!len)
 926                 return 1;
 927
 928         stm_get_locked_range(nor, sr, &lock_offs, &lock_len);
 929
 930         if (locked)
 931                 /* Requested range is a sub-range of locked range */
 932                 return (ofs + len <= lock_offs + lock_len) && (ofs >= lock_offs);
 933         else
 934                 /* Requested range does not overlap with locked range */
 935                 return (ofs >= lock_offs + lock_len) || (ofs + len <= lock_offs);
 936 }
 937
 938 static int stm_is_locked_sr(struct spi_nor *nor, loff_t ofs, uint64_t len,
 939                             u8 sr)
 940 {
 941         return stm_check_lock_status_sr(nor, ofs, len, sr, true);
 942 }
 943
 944 static int stm_is_unlocked_sr(struct spi_nor *nor, loff_t ofs, uint64_t len,
 945                               u8 sr)
 946 {
 947         return stm_check_lock_status_sr(nor, ofs, len, sr, false);
 948 }
 949
 950 /*
 951  * Lock a region of the flash. Compatible with ST Micro and similar flash.
 952  * Supports the block protection bits BP{0,1,2} in the status register
 953  * (SR). Does not support these features found in newer SR bitfields:
 954  *   - SEC: sector/block protect - only handle SEC=0 (block protect)
 955  *   - CMP: complement protect - only support CMP=0 (range is not complemented)
 956  *
 957  * Support for the following is provided conditionally for some flash:
 958  *   - TB: top/bottom protect
 959  *
 960  * Sample table portion for 8MB flash (Winbond w25q64fw):
 961  *
 962  *   SEC  |  TB   |  BP2  |  BP1  |  BP0  |  Prot Length  | Protected Portion
 963  *  --------------------------------------------------------------------------
 964  *    X   |   X   |   0   |   0   |   0   |  NONE         | NONE
 965  *    0   |   0   |   0   |   0   |   1   |  128 KB       | Upper 1/64
 966  *    0   |   0   |   0   |   1   |   0   |  256 KB       | Upper 1/32
 967  *    0   |   0   |   0   |   1   |   1   |  512 KB       | Upper 1/16
 968  *    0   |   0   |   1   |   0   |   0   |  1 MB         | Upper 1/8
 969  *    0   |   0   |   1   |   0   |   1   |  2 MB         | Upper 1/4
 970  *    0   |   0   |   1   |   1   |   0   |  4 MB         | Upper 1/2
 971  *    X   |   X   |   1   |   1   |   1   |  8 MB         | ALL
 972  *  ------|-------|-------|-------|-------|---------------|-------------------
 973  *    0   |   1   |   0   |   0   |   1   |  128 KB       | Lower 1/64
 974  *    0   |   1   |   0   |   1   |   0   |  256 KB       | Lower 1/32
 975  *    0   |   1   |   0   |   1   |   1   |  512 KB       | Lower 1/16
 976  *    0   |   1   |   1   |   0   |   0   |  1 MB         | Lower 1/8
 977  *    0   |   1   |   1   |   0   |   1   |  2 MB         | Lower 1/4
 978  *    0   |   1   |   1   |   1   |   0   |  4 MB         | Lower 1/2
 979  *
 980  * Returns negative on errors, 0 on success.
 981  */
 982 static int stm_lock(struct spi_nor *nor, loff_t ofs, uint64_t len)
 983 {
 984         struct mtd_info *mtd = &nor->mtd;
 985         int status_old, status_new;
 986         u8 mask = SR_BP2 | SR_BP1 | SR_BP0;
 987         u8 shift = ffs(mask) - 1, pow, val;
 988         loff_t lock_len;
 989         bool can_be_top = true, can_be_bottom = nor->flags & SNOR_F_HAS_SR_TB;
 990         bool use_top;
 991
 992         status_old = read_sr(nor);
 993         if (status_old < 0)
 994                 return status_old;
 995
 996         /* If nothing in our range is unlocked, we don't need to do anything */
 997         if (stm_is_locked_sr(nor, ofs, len, status_old))
 998                 return 0;
 999
1000         /* If anything below us is unlocked, we can't use 'bottom' protection */
1001         if (!stm_is_locked_sr(nor, 0, ofs, status_old))
1002                 can_be_bottom = false;
1003
1004         /* If anything above us is unlocked, we can't use 'top' protection */
1005         if (!stm_is_locked_sr(nor, ofs + len, mtd->size - (ofs + len),
1006                                 status_old))
1007                 can_be_top = false;
1008
1009         if (!can_be_bottom && !can_be_top)
1010                 return -EINVAL;
1011
1012         /* Prefer top, if both are valid */
1013         use_top = can_be_top;
1014
1015         /* lock_len: length of region that should end up locked */
1016         if (use_top)
1017                 lock_len = mtd->size - ofs;
1018         else
1019                 lock_len = ofs + len;
1020
1021         /*
1022          * Need smallest pow such that:
1023          *
1024          *   1 / (2^pow) <= (len / size)
1025          *
1026          * so (assuming power-of-2 size) we do:
1027          *
1028          *   pow = ceil(log2(size / len)) = log2(size) - floor(log2(len))
1029          */
1030         pow = ilog2(mtd->size) - ilog2(lock_len);
1031         val = mask - (pow << shift);
1032         if (val & ~mask)
1033                 return -EINVAL;
1034         /* Don't "lock" with no region! */
1035         if (!(val & mask))
1036                 return -EINVAL;
1037
1038         status_new = (status_old & ~mask & ~SR_TB) | val;
1039
1040         /* Disallow further writes if WP pin is asserted */
1041         status_new |= SR_SRWD;
1042
1043         if (!use_top)
1044                 status_new |= SR_TB;
1045
1046         /* Don't bother if they're the same */
1047         if (status_new == status_old)
1048                 return 0;
1049
1050         /* Only modify protection if it will not unlock other areas */
1051         if ((status_new & mask) < (status_old & mask))
1052                 return -EINVAL;
1053
1054         return write_sr_and_check(nor, status_new, mask);
1055 }
1056
1057 /*
1058  * Unlock a region of the flash. See stm_lock() for more info
1059  *
1060  * Returns negative on errors, 0 on success.
1061  */
1062 static int stm_unlock(struct spi_nor *nor, loff_t ofs, uint64_t len)
1063 {
1064         struct mtd_info *mtd = &nor->mtd;
1065         int status_old, status_new;
1066         u8 mask = SR_BP2 | SR_BP1 | SR_BP0;
1067         u8 shift = ffs(mask) - 1, pow, val;
1068         loff_t lock_len;
1069         bool can_be_top = true, can_be_bottom = nor->flags & SNOR_F_HAS_SR_TB;
1070         bool use_top;
1071
1072         status_old = read_sr(nor);
1073         if (status_old < 0)
1074                 return status_old;
1075
1076         /* If nothing in our range is locked, we don't need to do anything */
1077         if (stm_is_unlocked_sr(nor, ofs, len, status_old))
1078                 return 0;
1079
1080         /* If anything below us is locked, we can't use 'top' protection */
1081         if (!stm_is_unlocked_sr(nor, 0, ofs, status_old))
1082                 can_be_top = false;
1083
1084         /* If anything above us is locked, we can't use 'bottom' protection */
1085         if (!stm_is_unlocked_sr(nor, ofs + len, mtd->size - (ofs + len),
1086                                 status_old))
1087                 can_be_bottom = false;
1088
1089         if (!can_be_bottom && !can_be_top)
1090                 return -EINVAL;
1091
1092         /* Prefer top, if both are valid */
1093         use_top = can_be_top;
1094
1095         /* lock_len: length of region that should remain locked */
1096         if (use_top)
1097                 lock_len = mtd->size - (ofs + len);
1098         else
1099                 lock_len = ofs;
1100
1101         /*
1102          * Need largest pow such that:
1103          *
1104          *   1 / (2^pow) >= (len / size)
1105          *
1106          * so (assuming power-of-2 size) we do:
1107          *
1108          *   pow = floor(log2(size / len)) = log2(size) - ceil(log2(len))
1109          */
1110         pow = ilog2(mtd->size) - order_base_2(lock_len);
1111         if (lock_len == 0) {
1112                 val = 0; /* fully unlocked */
1113         } else {
1114                 val = mask - (pow << shift);
1115                 /* Some power-of-two sizes are not supported */
1116                 if (val & ~mask)
1117                         return -EINVAL;
1118         }
1119
1120         status_new = (status_old & ~mask & ~SR_TB) | val;
1121
1122         /* Don't protect status register if we're fully unlocked */
1123         if (lock_len == 0)
1124                 status_new &= ~SR_SRWD;
1125
1126         if (!use_top)
1127                 status_new |= SR_TB;
1128
1129         /* Don't bother if they're the same */
1130         if (status_new == status_old)
1131                 return 0;
1132
1133         /* Only modify protection if it will not lock other areas */
1134         if ((status_new & mask) > (status_old & mask))
1135                 return -EINVAL;
1136
1137         return write_sr_and_check(nor, status_new, mask);
1138 }
1139
1140 /*
1141  * Check if a region of the flash is (completely) locked. See stm_lock() for
1142  * more info.
1143  *
1144  * Returns 1 if entire region is locked, 0 if any portion is unlocked, and
1145  * negative on errors.
1146  */
1147 static int stm_is_locked(struct spi_nor *nor, loff_t ofs, uint64_t len)
1148 {
1149         int status;
1150
1151         status = read_sr(nor);
1152         if (status < 0)
1153                 return status;
1154
1155         return stm_is_locked_sr(nor, ofs, len, status);
1156 }
1157
1158 static int spi_nor_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
1159 {
1160         struct spi_nor *nor = mtd_to_spi_nor(mtd);
1161         int ret;
1162
1163         ret = spi_nor_lock_and_prep(nor, SPI_NOR_OPS_LOCK);
1164         if (ret)
1165                 return ret;
1166
1167         ret = nor->flash_lock(nor, ofs, len);
1168
1169         spi_nor_unlock_and_unprep(nor, SPI_NOR_OPS_UNLOCK);
1170         return ret;
1171 }
1172
1173 static int spi_nor_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
1174 {
1175         struct spi_nor *nor = mtd_to_spi_nor(mtd);
1176         int ret;
1177
1178         ret = spi_nor_lock_and_prep(nor, SPI_NOR_OPS_UNLOCK);
1179         if (ret)
1180                 return ret;
1181
1182         ret = nor->flash_unlock(nor, ofs, len);
1183
1184         spi_nor_unlock_and_unprep(nor, SPI_NOR_OPS_LOCK);
1185         return ret;
1186 }
1187
1188 static int spi_nor_is_locked(struct mtd_info *mtd, loff_t ofs, uint64_t len)
1189 {
1190         struct spi_nor *nor = mtd_to_spi_nor(mtd);
1191         int ret;
1192
1193         ret = spi_nor_lock_and_prep(nor, SPI_NOR_OPS_UNLOCK);
1194         if (ret)
1195                 return ret;
1196
1197         ret = nor->flash_is_locked(nor, ofs, len);
1198
1199         spi_nor_unlock_and_unprep(nor, SPI_NOR_OPS_LOCK);
1200         return ret;
1201 }
1202
1203 static int macronix_quad_enable(struct spi_nor *nor);
1204
1205 /* Used when the "_ext_id" is two bytes at most */
1206 #define INFO(_jedec_id, _ext_id, _sector_size, _n_sectors, _flags)      \
1207                 .id = {                                                 \
1208                         ((_jedec_id) >> 16) & 0xff,                     \
1209                         ((_jedec_id) >> 8) & 0xff,                      \
1210                         (_jedec_id) & 0xff,                             \
1211                         ((_ext_id) >> 8) & 0xff,                        \
1212                         (_ext_id) & 0xff,                               \
1213                         },                                              \
1214                 .id_len = (!(_jedec_id) ? 0 : (3 + ((_ext_id) ? 2 : 0))),       \
1215                 .sector_size = (_sector_size),                          \
1216                 .n_sectors = (_n_sectors),                              \
1217                 .page_size = 256,                                       \
1218                 .flags = (_flags),
1219
1220 #define INFO6(_jedec_id, _ext_id, _sector_size, _n_sectors, _flags)     \
1221                 .id = {                                                 \
1222                         ((_jedec_id) >> 16) & 0xff,                     \
1223                         ((_jedec_id) >> 8) & 0xff,                      \
1224                         (_jedec_id) & 0xff,                             \
1225                         ((_ext_id) >> 16) & 0xff,                       \
1226                         ((_ext_id) >> 8) & 0xff,                        \
1227                         (_ext_id) & 0xff,                               \
1228                         },                                              \
1229                 .id_len = 6,                                            \
1230                 .sector_size = (_sector_size),                          \
1231                 .n_sectors = (_n_sectors),                              \
1232                 .page_size = 256,                                       \
1233                 .flags = (_flags),
1234
1235 #define CAT25_INFO(_sector_size, _n_sectors, _page_size, _addr_width, _flags)   \
1236                 .sector_size = (_sector_size),                          \
1237                 .n_sectors = (_n_sectors),                              \
1238                 .page_size = (_page_size),                              \
1239                 .addr_width = (_addr_width),                            \
1240                 .flags = (_flags),
1241
1242 #define S3AN_INFO(_jedec_id, _n_sectors, _page_size)                    \
1243                 .id = {                                                 \
1244                         ((_jedec_id) >> 16) & 0xff,                     \
1245                         ((_jedec_id) >> 8) & 0xff,                      \
1246                         (_jedec_id) & 0xff                              \
1247                         },                                              \
1248                 .id_len = 3,                                            \
1249                 .sector_size = (8*_page_size),                          \
1250                 .n_sectors = (_n_sectors),                              \
1251                 .page_size = _page_size,                                \
1252                 .addr_width = 3,                                        \
1253                 .flags = SPI_NOR_NO_FR | SPI_S3AN,
1254
1255 /* NOTE: double check command sets and memory organization when you add
1256  * more nor chips.  This current list focusses on newer chips, which
1257  * have been converging on command sets which including JEDEC ID.
1258  *
1259  * All newly added entries should describe *hardware* and should use SECT_4K
1260  * (or SECT_4K_PMC) if hardware supports erasing 4 KiB sectors. For usage
1261  * scenarios excluding small sectors there is config option that can be
1262  * disabled: CONFIG_MTD_SPI_NOR_USE_4K_SECTORS.
1263  * For historical (and compatibility) reasons (before we got above config) some
1264  * old entries may be missing 4K flag.
1265  */
1266 static const struct flash_info spi_nor_ids[] = {
1267         /* Atmel -- some are (confusingly) marketed as "DataFlash" */
1268         { "at25fs010",  INFO(0x1f6601, 0, 32 * 1024,   4, SECT_4K) },
1269         { "at25fs040",  INFO(0x1f6604, 0, 64 * 1024,   8, SECT_4K) },
1270
1271         { "at25df041a", INFO(0x1f4401, 0, 64 * 1024,   8, SECT_4K) },
1272         { "at25df321",  INFO(0x1f4700, 0, 64 * 1024,  64, SECT_4K) },
1273         { "at25df321a", INFO(0x1f4701, 0, 64 * 1024,  64, SECT_4K) },
1274         { "at25df641",  INFO(0x1f4800, 0, 64 * 1024, 128, SECT_4K) },
1275
1276         { "at26f004",   INFO(0x1f0400, 0, 64 * 1024,  8, SECT_4K) },
1277         { "at26df081a", INFO(0x1f4501, 0, 64 * 1024, 16, SECT_4K) },
1278         { "at26df161a", INFO(0x1f4601, 0, 64 * 1024, 32, SECT_4K) },
1279         { "at26df321",  INFO(0x1f4700, 0, 64 * 1024, 64, SECT_4K) },
1280
1281         { "at45db081d", INFO(0x1f2500, 0, 64 * 1024, 16, SECT_4K) },
1282
1283         /* EON -- en25xxx */
1284         { "en25f32",    INFO(0x1c3116, 0, 64 * 1024,   64, SECT_4K) },
1285         { "en25p32",    INFO(0x1c2016, 0, 64 * 1024,   64, 0) },
1286         { "en25q32b",   INFO(0x1c3016, 0, 64 * 1024,   64, 0) },
1287         { "en25p64",    INFO(0x1c2017, 0, 64 * 1024,  128, 0) },
1288         { "en25q64",    INFO(0x1c3017, 0, 64 * 1024,  128, SECT_4K) },
1289         { "en25qh32",   INFO(0x1c7016, 0, 64 * 1024,   64, 0) },
1290         { "en25qh128",  INFO(0x1c7018, 0, 64 * 1024,  256, 0) },
1291         { "en25qh256",  INFO(0x1c7019, 0, 64 * 1024,  512, 0) },
1292         { "en25s64",    INFO(0x1c3817, 0, 64 * 1024,  128, SECT_4K) },
1293
1294         /* ESMT */
1295         { "f25l32pa", INFO(0x8c2016, 0, 64 * 1024, 64, SECT_4K | SPI_NOR_HAS_LOCK) },
1296         { "f25l32qa", INFO(0x8c4116, 0, 64 * 1024, 64, SECT_4K | SPI_NOR_HAS_LOCK) },
1297         { "f25l64qa", INFO(0x8c4117, 0, 64 * 1024, 128, SECT_4K | SPI_NOR_HAS_LOCK) },
1298
1299         /* Everspin */
1300         { "mr25h128", CAT25_INFO( 16 * 1024, 1, 256, 2, SPI_NOR_NO_ERASE | SPI_NOR_NO_FR) },
1301         { "mr25h256", CAT25_INFO( 32 * 1024, 1, 256, 2, SPI_NOR_NO_ERASE | SPI_NOR_NO_FR) },
1302         { "mr25h10",  CAT25_INFO(128 * 1024, 1, 256, 3, SPI_NOR_NO_ERASE | SPI_NOR_NO_FR) },
1303         { "mr25h40",  CAT25_INFO(512 * 1024, 1, 256, 3, SPI_NOR_NO_ERASE | SPI_NOR_NO_FR) },
1304
1305         /* Fujitsu */
1306         { "mb85rs1mt", INFO(0x047f27, 0, 128 * 1024, 1, SPI_NOR_NO_ERASE) },
1307
1308         /* GigaDevice */
1309         {
1310                 "gd25q16", INFO(0xc84015, 0, 64 * 1024,  32,
1311                         SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ |
1312                         SPI_NOR_HAS_LOCK | SPI_NOR_HAS_TB)
1313         },
1314         {
1315                 "gd25q32", INFO(0xc84016, 0, 64 * 1024,  64,
1316                         SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ |
1317                         SPI_NOR_HAS_LOCK | SPI_NOR_HAS_TB)
1318         },
1319         {
1320                 "gd25lq32", INFO(0xc86016, 0, 64 * 1024, 64,
1321                         SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ |
1322                         SPI_NOR_HAS_LOCK | SPI_NOR_HAS_TB)
1323         },
1324         {
1325                 "gd25q64", INFO(0xc84017, 0, 64 * 1024, 128,
1326                         SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ |
1327                         SPI_NOR_HAS_LOCK | SPI_NOR_HAS_TB)
1328         },
1329         {
1330                 "gd25lq64c", INFO(0xc86017, 0, 64 * 1024, 128,
1331                         SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ |
1332                         SPI_NOR_HAS_LOCK | SPI_NOR_HAS_TB)
1333         },
1334         {
1335                 "gd25q128", INFO(0xc84018, 0, 64 * 1024, 256,
1336                         SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ |
1337                         SPI_NOR_HAS_LOCK | SPI_NOR_HAS_TB)
1338         },
1339         {
1340                 "gd25q256", INFO(0xc84019, 0, 64 * 1024, 512,
1341                         SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ |
1342                         SPI_NOR_4B_OPCODES | SPI_NOR_HAS_LOCK | SPI_NOR_HAS_TB)
1343                         .quad_enable = macronix_quad_enable,
1344         },
1345
1346         /* Intel/Numonyx -- xxxs33b */
1347         { "160s33b",  INFO(0x898911, 0, 64 * 1024,  32, 0) },
1348         { "320s33b",  INFO(0x898912, 0, 64 * 1024,  64, 0) },
1349         { "640s33b",  INFO(0x898913, 0, 64 * 1024, 128, 0) },
1350
1351         /* ISSI */
1352         { "is25cd512",  INFO(0x7f9d20, 0, 32 * 1024,   2, SECT_4K) },
1353         { "is25lq040b", INFO(0x9d4013, 0, 64 * 1024,   8,
1354                         SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
1355         { "is25lp080d", INFO(0x9d6014, 0, 64 * 1024,  16,
1356                         SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
1357         { "is25lp128",  INFO(0x9d6018, 0, 64 * 1024, 256,
1358                         SECT_4K | SPI_NOR_DUAL_READ) },
1359         { "is25lp256",  INFO(0x9d6019, 0, 64 * 1024, 512,
1360                         SECT_4K | SPI_NOR_DUAL_READ) },
1361         { "is25wp032",  INFO(0x9d7016, 0, 64 * 1024,  64,
1362                         SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
1363         { "is25wp064",  INFO(0x9d7017, 0, 64 * 1024, 128,
1364                         SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
1365         { "is25wp128",  INFO(0x9d7018, 0, 64 * 1024, 256,
1366                         SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
1367
1368         /* Macronix */
1369         { "mx25l512e",   INFO(0xc22010, 0, 64 * 1024,   1, SECT_4K) },
1370         { "mx25l2005a",  INFO(0xc22012, 0, 64 * 1024,   4, SECT_4K) },
1371         { "mx25l4005a",  INFO(0xc22013, 0, 64 * 1024,   8, SECT_4K) },
1372         { "mx25l8005",   INFO(0xc22014, 0, 64 * 1024,  16, 0) },
1373         { "mx25l1606e",  INFO(0xc22015, 0, 64 * 1024,  32, SECT_4K) },
1374         { "mx25l3205d",  INFO(0xc22016, 0, 64 * 1024,  64, SECT_4K) },
1375         { "mx25l3255e",  INFO(0xc29e16, 0, 64 * 1024,  64, SECT_4K) },
1376         { "mx25l6405d",  INFO(0xc22017, 0, 64 * 1024, 128, SECT_4K) },
1377         { "mx25u2033e",  INFO(0xc22532, 0, 64 * 1024,   4, SECT_4K) },
1378         { "mx25u4035",   INFO(0xc22533, 0, 64 * 1024,   8, SECT_4K) },
1379         { "mx25u8035",   INFO(0xc22534, 0, 64 * 1024,  16, SECT_4K) },
1380         { "mx25u6435f",  INFO(0xc22537, 0, 64 * 1024, 128, SECT_4K) },
1381         { "mx25l12805d", INFO(0xc22018, 0, 64 * 1024, 256, 0) },
1382         { "mx25l12855e", INFO(0xc22618, 0, 64 * 1024, 256, 0) },
1383         { "mx25l25635e", INFO(0xc22019, 0, 64 * 1024, 512, SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
1384         { "mx25u25635f", INFO(0xc22539, 0, 64 * 1024, 512, SECT_4K | SPI_NOR_4B_OPCODES) },
1385         { "mx25l25655e", INFO(0xc22619, 0, 64 * 1024, 512, 0) },
1386         { "mx66l51235l", INFO(0xc2201a, 0, 64 * 1024, 1024, SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ | SPI_NOR_4B_OPCODES) },
1387         { "mx66u51235f", INFO(0xc2253a, 0, 64 * 1024, 1024, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ | SPI_NOR_4B_OPCODES) },
1388         { "mx66l1g45g",  INFO(0xc2201b, 0, 64 * 1024, 2048, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
1389         { "mx66l1g55g",  INFO(0xc2261b, 0, 64 * 1024, 2048, SPI_NOR_QUAD_READ) },
1390
1391         /* Micron */
1392         { "n25q016a",    INFO(0x20bb15, 0, 64 * 1024,   32, SECT_4K | SPI_NOR_QUAD_READ) },
1393         { "n25q032",     INFO(0x20ba16, 0, 64 * 1024,   64, SPI_NOR_QUAD_READ) },
1394         { "n25q032a",    INFO(0x20bb16, 0, 64 * 1024,   64, SPI_NOR_QUAD_READ) },
1395         { "n25q064",     INFO(0x20ba17, 0, 64 * 1024,  128, SECT_4K | SPI_NOR_QUAD_READ) },
1396         { "n25q064a",    INFO(0x20bb17, 0, 64 * 1024,  128, SECT_4K | SPI_NOR_QUAD_READ) },
1397         { "n25q128a11",  INFO(0x20bb18, 0, 64 * 1024,  256, SECT_4K | SPI_NOR_QUAD_READ) },
1398         { "n25q128a13",  INFO(0x20ba18, 0, 64 * 1024,  256, SECT_4K | SPI_NOR_QUAD_READ) },
1399         { "n25q256a",    INFO(0x20ba19, 0, 64 * 1024,  512, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
1400         { "n25q256ax1",  INFO(0x20bb19, 0, 64 * 1024,  512, SECT_4K | SPI_NOR_QUAD_READ) },
1401         { "n25q512a",    INFO(0x20bb20, 0, 64 * 1024, 1024, SECT_4K | USE_FSR | SPI_NOR_QUAD_READ) },
1402         { "n25q512ax3",  INFO(0x20ba20, 0, 64 * 1024, 1024, SECT_4K | USE_FSR | SPI_NOR_QUAD_READ) },
1403         { "n25q00",      INFO(0x20ba21, 0, 64 * 1024, 2048, SECT_4K | USE_FSR | SPI_NOR_QUAD_READ | NO_CHIP_ERASE) },
1404         { "n25q00a",     INFO(0x20bb21, 0, 64 * 1024, 2048, SECT_4K | USE_FSR | SPI_NOR_QUAD_READ | NO_CHIP_ERASE) },
1405         { "mt25qu02g",   INFO(0x20bb22, 0, 64 * 1024, 4096, SECT_4K | USE_FSR | SPI_NOR_QUAD_READ | NO_CHIP_ERASE) },
1406
1407         /* PMC */
1408         { "pm25lv512",   INFO(0,        0, 32 * 1024,    2, SECT_4K_PMC) },
1409         { "pm25lv010",   INFO(0,        0, 32 * 1024,    4, SECT_4K_PMC) },
1410         { "pm25lq032",   INFO(0x7f9d46, 0, 64 * 1024,   64, SECT_4K) },
1411
1412         /* Spansion/Cypress -- single (large) sector size only, at least
1413          * for the chips listed here (without boot sectors).
1414          */
1415         { "s25sl032p",  INFO(0x010215, 0x4d00,  64 * 1024,  64, SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
1416         { "s25sl064p",  INFO(0x010216, 0x4d00,  64 * 1024, 128, SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
1417         { "s25fl256s0", INFO(0x010219, 0x4d00, 256 * 1024, 128, USE_CLSR) },
1418         { "s25fl256s1", INFO(0x010219, 0x4d01,  64 * 1024, 512, SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ | USE_CLSR) },
1419         { "s25fl512s",  INFO(0x010220, 0x4d00, 256 * 1024, 256, SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ | USE_CLSR) },
1420         { "s70fl01gs",  INFO(0x010221, 0x4d00, 256 * 1024, 256, 0) },
1421         { "s25sl12800", INFO(0x012018, 0x0300, 256 * 1024,  64, 0) },
1422         { "s25sl12801", INFO(0x012018, 0x0301,  64 * 1024, 256, 0) },
1423         { "s25fl128s",  INFO6(0x012018, 0x4d0180, 64 * 1024, 256, SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ | USE_CLSR) },
1424         { "s25fl129p0", INFO(0x012018, 0x4d00, 256 * 1024,  64, SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ | USE_CLSR) },
1425         { "s25fl129p1", INFO(0x012018, 0x4d01,  64 * 1024, 256, SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ | USE_CLSR) },
1426         { "s25sl004a",  INFO(0x010212,      0,  64 * 1024,   8, 0) },
1427         { "s25sl008a",  INFO(0x010213,      0,  64 * 1024,  16, 0) },
1428         { "s25sl016a",  INFO(0x010214,      0,  64 * 1024,  32, 0) },
1429         { "s25sl032a",  INFO(0x010215,      0,  64 * 1024,  64, 0) },
1430         { "s25sl064a",  INFO(0x010216,      0,  64 * 1024, 128, 0) },
1431         { "s25fl004k",  INFO(0xef4013,      0,  64 * 1024,   8, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
1432         { "s25fl008k",  INFO(0xef4014,      0,  64 * 1024,  16, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
1433         { "s25fl016k",  INFO(0xef4015,      0,  64 * 1024,  32, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
1434         { "s25fl064k",  INFO(0xef4017,      0,  64 * 1024, 128, SECT_4K) },
1435         { "s25fl116k",  INFO(0x014015,      0,  64 * 1024,  32, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
1436         { "s25fl132k",  INFO(0x014016,      0,  64 * 1024,  64, SECT_4K) },
1437         { "s25fl164k",  INFO(0x014017,      0,  64 * 1024, 128, SECT_4K) },
1438         { "s25fl204k",  INFO(0x014013,      0,  64 * 1024,   8, SECT_4K | SPI_NOR_DUAL_READ) },
1439         { "s25fl208k",  INFO(0x014014,      0,  64 * 1024,  16, SECT_4K | SPI_NOR_DUAL_READ) },
1440         { "s25fl064l",  INFO(0x016017,      0,  64 * 1024, 128, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ | SPI_NOR_4B_OPCODES) },
1441         { "s25fl128l",  INFO(0x016018,      0,  64 * 1024, 256, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ | SPI_NOR_4B_OPCODES) },
1442         { "s25fl256l",  INFO(0x016019,      0,  64 * 1024, 512, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ | SPI_NOR_4B_OPCODES) },
1443
1444         /* SST -- large erase sizes are "overlays", "sectors" are 4K */
1445         { "sst25vf040b", INFO(0xbf258d, 0, 64 * 1024,  8, SECT_4K | SST_WRITE) },
1446         { "sst25vf080b", INFO(0xbf258e, 0, 64 * 1024, 16, SECT_4K | SST_WRITE) },
1447         { "sst25vf016b", INFO(0xbf2541, 0, 64 * 1024, 32, SECT_4K | SST_WRITE) },
1448         { "sst25vf032b", INFO(0xbf254a, 0, 64 * 1024, 64, SECT_4K | SST_WRITE) },
1449         { "sst25vf064c", INFO(0xbf254b, 0, 64 * 1024, 128, SECT_4K) },
1450         { "sst25wf512",  INFO(0xbf2501, 0, 64 * 1024,  1, SECT_4K | SST_WRITE) },
1451         { "sst25wf010",  INFO(0xbf2502, 0, 64 * 1024,  2, SECT_4K | SST_WRITE) },
1452         { "sst25wf020",  INFO(0xbf2503, 0, 64 * 1024,  4, SECT_4K | SST_WRITE) },
1453         { "sst25wf020a", INFO(0x621612, 0, 64 * 1024,  4, SECT_4K) },
1454         { "sst25wf040b", INFO(0x621613, 0, 64 * 1024,  8, SECT_4K) },
1455         { "sst25wf040",  INFO(0xbf2504, 0, 64 * 1024,  8, SECT_4K | SST_WRITE) },
1456         { "sst25wf080",  INFO(0xbf2505, 0, 64 * 1024, 16, SECT_4K | SST_WRITE) },
1457         { "sst26vf064b", INFO(0xbf2643, 0, 64 * 1024, 128, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
1458
1459         /* ST Microelectronics -- newer production may have feature updates */
1460         { "m25p05",  INFO(0x202010,  0,  32 * 1024,   2, 0) },
1461         { "m25p10",  INFO(0x202011,  0,  32 * 1024,   4, 0) },
1462         { "m25p20",  INFO(0x202012,  0,  64 * 1024,   4, 0) },
1463         { "m25p40",  INFO(0x202013,  0,  64 * 1024,   8, 0) },
1464         { "m25p80",  INFO(0x202014,  0,  64 * 1024,  16, 0) },
1465         { "m25p16",  INFO(0x202015,  0,  64 * 1024,  32, 0) },
1466         { "m25p32",  INFO(0x202016,  0,  64 * 1024,  64, 0) },
1467         { "m25p64",  INFO(0x202017,  0,  64 * 1024, 128, 0) },
1468         { "m25p128", INFO(0x202018,  0, 256 * 1024,  64, 0) },
1469
1470         { "m25p05-nonjedec",  INFO(0, 0,  32 * 1024,   2, 0) },
1471         { "m25p10-nonjedec",  INFO(0, 0,  32 * 1024,   4, 0) },
1472         { "m25p20-nonjedec",  INFO(0, 0,  64 * 1024,   4, 0) },
1473         { "m25p40-nonjedec",  INFO(0, 0,  64 * 1024,   8, 0) },
1474         { "m25p80-nonjedec",  INFO(0, 0,  64 * 1024,  16, 0) },
1475         { "m25p16-nonjedec",  INFO(0, 0,  64 * 1024,  32, 0) },
1476         { "m25p32-nonjedec",  INFO(0, 0,  64 * 1024,  64, 0) },
1477         { "m25p64-nonjedec",  INFO(0, 0,  64 * 1024, 128, 0) },
1478         { "m25p128-nonjedec", INFO(0, 0, 256 * 1024,  64, 0) },
1479
1480         { "m45pe10", INFO(0x204011,  0, 64 * 1024,    2, 0) },
1481         { "m45pe80", INFO(0x204014,  0, 64 * 1024,   16, 0) },
1482         { "m45pe16", INFO(0x204015,  0, 64 * 1024,   32, 0) },
1483
1484         { "m25pe20", INFO(0x208012,  0, 64 * 1024,  4,       0) },
1485         { "m25pe80", INFO(0x208014,  0, 64 * 1024, 16,       0) },
1486         { "m25pe16", INFO(0x208015,  0, 64 * 1024, 32, SECT_4K) },
1487
1488         { "m25px16",    INFO(0x207115,  0, 64 * 1024, 32, SECT_4K) },
1489         { "m25px32",    INFO(0x207116,  0, 64 * 1024, 64, SECT_4K) },
1490         { "m25px32-s0", INFO(0x207316,  0, 64 * 1024, 64, SECT_4K) },
1491         { "m25px32-s1", INFO(0x206316,  0, 64 * 1024, 64, SECT_4K) },
1492         { "m25px64",    INFO(0x207117,  0, 64 * 1024, 128, 0) },
1493         { "m25px80",    INFO(0x207114,  0, 64 * 1024, 16, 0) },
1494
1495         /* Winbond -- w25x "blocks" are 64K, "sectors" are 4KiB */
1496         { "w25x05", INFO(0xef3010, 0, 64 * 1024,  1,  SECT_4K) },
1497         { "w25x10", INFO(0xef3011, 0, 64 * 1024,  2,  SECT_4K) },
1498         { "w25x20", INFO(0xef3012, 0, 64 * 1024,  4,  SECT_4K) },
1499         { "w25x40", INFO(0xef3013, 0, 64 * 1024,  8,  SECT_4K) },
1500         { "w25x80", INFO(0xef3014, 0, 64 * 1024,  16, SECT_4K) },
1501         { "w25x16", INFO(0xef3015, 0, 64 * 1024,  32, SECT_4K) },
1502         {
1503                 "w25q16dw", INFO(0xef6015, 0, 64 * 1024,  32,
1504                         SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ |
1505                         SPI_NOR_HAS_LOCK | SPI_NOR_HAS_TB)
1506         },
1507         { "w25x32", INFO(0xef3016, 0, 64 * 1024,  64, SECT_4K) },
1508         { "w25q20cl", INFO(0xef4012, 0, 64 * 1024,  4, SECT_4K) },
1509         { "w25q20bw", INFO(0xef5012, 0, 64 * 1024,  4, SECT_4K) },
1510         { "w25q20ew", INFO(0xef6012, 0, 64 * 1024,  4, SECT_4K) },
1511         { "w25q32", INFO(0xef4016, 0, 64 * 1024,  64, SECT_4K) },
1512         {
1513                 "w25q32dw", INFO(0xef6016, 0, 64 * 1024,  64,
1514                         SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ |
1515                         SPI_NOR_HAS_LOCK | SPI_NOR_HAS_TB)
1516         },
1517         {
1518                 "w25q32jv", INFO(0xef7016, 0, 64 * 1024,  64,
1519                         SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ |
1520                         SPI_NOR_HAS_LOCK | SPI_NOR_HAS_TB)
1521         },
1522         { "w25x64", INFO(0xef3017, 0, 64 * 1024, 128, SECT_4K) },
1523         { "w25q64", INFO(0xef4017, 0, 64 * 1024, 128, SECT_4K) },
1524         {
1525                 "w25q64dw", INFO(0xef6017, 0, 64 * 1024, 128,
1526                         SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ |
1527                         SPI_NOR_HAS_LOCK | SPI_NOR_HAS_TB)
1528         },
1529         {
1530                 "w25q128fw", INFO(0xef6018, 0, 64 * 1024, 256,
1531                         SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ |
1532                         SPI_NOR_HAS_LOCK | SPI_NOR_HAS_TB)
1533         },
1534         { "w25q80", INFO(0xef5014, 0, 64 * 1024,  16, SECT_4K) },
1535         { "w25q80bl", INFO(0xef4014, 0, 64 * 1024,  16, SECT_4K) },
1536         { "w25q128", INFO(0xef4018, 0, 64 * 1024, 256, SECT_4K) },
1537         { "w25q256", INFO(0xef4019, 0, 64 * 1024, 512, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
1538         { "w25m512jv", INFO(0xef7119, 0, 64 * 1024, 1024,
1539                         SECT_4K | SPI_NOR_QUAD_READ | SPI_NOR_DUAL_READ) },
1540
1541         /* Catalyst / On Semiconductor -- non-JEDEC */
1542         { "cat25c11", CAT25_INFO(  16, 8, 16, 1, SPI_NOR_NO_ERASE | SPI_NOR_NO_FR) },
1543         { "cat25c03", CAT25_INFO(  32, 8, 16, 2, SPI_NOR_NO_ERASE | SPI_NOR_NO_FR) },
1544         { "cat25c09", CAT25_INFO( 128, 8, 32, 2, SPI_NOR_NO_ERASE | SPI_NOR_NO_FR) },
1545         { "cat25c17", CAT25_INFO( 256, 8, 32, 2, SPI_NOR_NO_ERASE | SPI_NOR_NO_FR) },
1546         { "cat25128", CAT25_INFO(2048, 8, 64, 2, SPI_NOR_NO_ERASE | SPI_NOR_NO_FR) },
1547
1548         /* Xilinx S3AN Internal Flash */
1549         { "3S50AN", S3AN_INFO(0x1f2200, 64, 264) },
1550         { "3S200AN", S3AN_INFO(0x1f2400, 256, 264) },
1551         { "3S400AN", S3AN_INFO(0x1f2400, 256, 264) },
1552         { "3S700AN", S3AN_INFO(0x1f2500, 512, 264) },
1553         { "3S1400AN", S3AN_INFO(0x1f2600, 512, 528) },
1554
1555         /* XMC (Wuhan Xinxin Semiconductor Manufacturing Corp.) */
1556         { "XM25QH64A", INFO(0x207017, 0, 64 * 1024, 128, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
1557         { "XM25QH128A", INFO(0x207018, 0, 64 * 1024, 256, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
1558         { },
1559 };
1560
1561 static const struct flash_info *spi_nor_read_id(struct spi_nor *nor)
1562 {
1563         int                     tmp;
1564         u8                      id[SPI_NOR_MAX_ID_LEN];
1565         const struct flash_info *info;
1566
1567         tmp = nor->read_reg(nor, SPINOR_OP_RDID, id, SPI_NOR_MAX_ID_LEN);
1568         if (tmp < 0) {
1569                 dev_dbg(nor->dev, "error %d reading JEDEC ID\n", tmp);
1570                 return ERR_PTR(tmp);
1571         }
1572
1573         for (tmp = 0; tmp < ARRAY_SIZE(spi_nor_ids) - 1; tmp++) {
1574                 info = &spi_nor_ids[tmp];
1575                 if (info->id_len) {
1576                         if (!memcmp(info->id, id, info->id_len))
1577                                 return &spi_nor_ids[tmp];
1578                 }
1579         }
1580         dev_err(nor->dev, "unrecognized JEDEC id bytes: %02x, %02x, %02x\n",
1581                 id[0], id[1], id[2]);
1582         return ERR_PTR(-ENODEV);
1583 }
1584
1585 static int spi_nor_read(struct mtd_info *mtd, loff_t from, size_t len,
1586                         size_t *retlen, u_char *buf)
1587 {
1588         struct spi_nor *nor = mtd_to_spi_nor(mtd);
1589         int ret;
1590
1591         dev_dbg(nor->dev, "from 0x%08x, len %zd\n", (u32)from, len);
1592
1593         ret = spi_nor_lock_and_prep(nor, SPI_NOR_OPS_READ);
1594         if (ret)
1595                 return ret;
1596
1597         while (len) {
1598                 loff_t addr = from;
1599
1600                 if (nor->flags & SNOR_F_S3AN_ADDR_DEFAULT)
1601                         addr = spi_nor_s3an_addr_convert(nor, addr);
1602
1603                 ret = nor->read(nor, addr, len, buf);
1604                 if (ret == 0) {
1605                         /* We shouldn't see 0-length reads */
1606                         ret = -EIO;
1607                         goto read_err;
1608                 }
1609                 if (ret < 0)
1610                         goto read_err;
1611
1612                 WARN_ON(ret > len);
1613                 *retlen += ret;
1614                 buf += ret;
1615                 from += ret;
1616                 len -= ret;
1617         }
1618         ret = 0;
1619
1620 read_err:
1621         spi_nor_unlock_and_unprep(nor, SPI_NOR_OPS_READ);
1622         return ret;
1623 }
1624
1625 static int sst_write(struct mtd_info *mtd, loff_t to, size_t len,
1626                 size_t *retlen, const u_char *buf)
1627 {
1628         struct spi_nor *nor = mtd_to_spi_nor(mtd);
1629         size_t actual;
1630         int ret;
1631
1632         dev_dbg(nor->dev, "to 0x%08x, len %zd\n", (u32)to, len);
1633
1634         ret = spi_nor_lock_and_prep(nor, SPI_NOR_OPS_WRITE);
1635         if (ret)
1636                 return ret;
1637
1638         write_enable(nor);
1639
1640         nor->sst_write_second = false;
1641
1642         actual = to % 2;
1643         /* Start write from odd address. */
1644         if (actual) {
1645                 nor->program_opcode = SPINOR_OP_BP;
1646
1647                 /* write one byte. */
1648                 ret = nor->write(nor, to, 1, buf);
1649                 if (ret < 0)
1650                         goto sst_write_err;
1651                 WARN(ret != 1, "While writing 1 byte written %i bytes\n",
1652                      (int)ret);
1653                 ret = spi_nor_wait_till_ready(nor);
1654                 if (ret)
1655                         goto sst_write_err;
1656         }
1657         to += actual;
1658
1659         /* Write out most of the data here. */
1660         for (; actual < len - 1; actual += 2) {
1661                 nor->program_opcode = SPINOR_OP_AAI_WP;
1662
1663                 /* write two bytes. */
1664                 ret = nor->write(nor, to, 2, buf + actual);
1665                 if (ret < 0)
1666                         goto sst_write_err;
1667                 WARN(ret != 2, "While writing 2 bytes written %i bytes\n",
1668                      (int)ret);
1669                 ret = spi_nor_wait_till_ready(nor);
1670                 if (ret)
1671                         goto sst_write_err;
1672                 to += 2;
1673                 nor->sst_write_second = true;
1674         }
1675         nor->sst_write_second = false;
1676
1677         write_disable(nor);
1678         ret = spi_nor_wait_till_ready(nor);
1679         if (ret)
1680                 goto sst_write_err;
1681
1682         /* Write out trailing byte if it exists. */
1683         if (actual != len) {
1684                 write_enable(nor);
1685
1686                 nor->program_opcode = SPINOR_OP_BP;
1687                 ret = nor->write(nor, to, 1, buf + actual);
1688                 if (ret < 0)
1689                         goto sst_write_err;
1690                 WARN(ret != 1, "While writing 1 byte written %i bytes\n",
1691                      (int)ret);
1692                 ret = spi_nor_wait_till_ready(nor);
1693                 if (ret)
1694                         goto sst_write_err;
1695                 write_disable(nor);
1696                 actual += 1;
1697         }
1698 sst_write_err:
1699         *retlen += actual;
1700         spi_nor_unlock_and_unprep(nor, SPI_NOR_OPS_WRITE);
1701         return ret;
1702 }
1703
1704 /*
1705  * Write an address range to the nor chip.  Data must be written in
1706  * FLASH_PAGESIZE chunks.  The address range may be any size provided
1707  * it is within the physical boundaries.
1708  */
1709 static int spi_nor_write(struct mtd_info *mtd, loff_t to, size_t len,
1710         size_t *retlen, const u_char *buf)
1711 {
1712         struct spi_nor *nor = mtd_to_spi_nor(mtd);
1713         size_t page_offset, page_remain, i;
1714         ssize_t ret;
1715
1716         dev_dbg(nor->dev, "to 0x%08x, len %zd\n", (u32)to, len);
1717
1718         ret = spi_nor_lock_and_prep(nor, SPI_NOR_OPS_WRITE);
1719         if (ret)
1720                 return ret;
1721
1722         for (i = 0; i < len; ) {
1723                 ssize_t written;
1724                 loff_t addr = to + i;
1725
1726                 /*
1727                  * If page_size is a power of two, the offset can be quickly
1728                  * calculated with an AND operation. On the other cases we
1729                  * need to do a modulus operation (more expensive).
1730                  * Power of two numbers have only one bit set and we can use
1731                  * the instruction hweight32 to detect if we need to do a
1732                  * modulus (do_div()) or not.
1733                  */
1734                 if (hweight32(nor->page_size) == 1) {
1735                         page_offset = addr & (nor->page_size - 1);
1736                 } else {
1737                         uint64_t aux = addr;
1738
1739                         page_offset = do_div(aux, nor->page_size);
1740                 }
1741                 /* the size of data remaining on the first page */
1742                 page_remain = min_t(size_t,
1743                                     nor->page_size - page_offset, len - i);
1744
1745                 if (nor->flags & SNOR_F_S3AN_ADDR_DEFAULT)
1746                         addr = spi_nor_s3an_addr_convert(nor, addr);
1747
1748                 write_enable(nor);
1749                 ret = nor->write(nor, addr, page_remain, buf + i);
1750                 if (ret < 0)
1751                         goto write_err;
1752                 written = ret;
1753
1754                 ret = spi_nor_wait_till_ready(nor);
1755                 if (ret)
1756                         goto write_err;
1757                 *retlen += written;
1758                 i += written;
1759         }
1760
1761 write_err:
1762         spi_nor_unlock_and_unprep(nor, SPI_NOR_OPS_WRITE);
1763         return ret;
1764 }
1765
1766 /**
1767  * macronix_quad_enable() - set QE bit in Status Register.
1768  * @nor:        pointer to a 'struct spi_nor'
1769  *
1770  * Set the Quad Enable (QE) bit in the Status Register.
1771  *
1772  * bit 6 of the Status Register is the QE bit for Macronix like QSPI memories.
1773  *
1774  * Return: 0 on success, -errno otherwise.
1775  */
1776 static int macronix_quad_enable(struct spi_nor *nor)
1777 {
1778         int ret, val;
1779
1780         val = read_sr(nor);
1781         if (val < 0)
1782                 return val;
1783         if (val & SR_QUAD_EN_MX)
1784                 return 0;
1785
1786         write_enable(nor);
1787
1788         write_sr(nor, val | SR_QUAD_EN_MX);
1789
1790         ret = spi_nor_wait_till_ready(nor);
1791         if (ret)
1792                 return ret;
1793
1794         ret = read_sr(nor);
1795         if (!(ret > 0 && (ret & SR_QUAD_EN_MX))) {
1796                 dev_err(nor->dev, "Macronix Quad bit not set\n");
1797                 return -EINVAL;
1798         }
1799
1800         return 0;
1801 }
1802
1803 /*
1804  * Write status Register and configuration register with 2 bytes
1805  * The first byte will be written to the status register, while the
1806  * second byte will be written to the configuration register.
1807  * Return negative if error occurred.
1808  */
1809 static int write_sr_cr(struct spi_nor *nor, u8 *sr_cr)
1810 {
1811         int ret;
1812
1813         write_enable(nor);
1814
1815         ret = nor->write_reg(nor, SPINOR_OP_WRSR, sr_cr, 2);
1816         if (ret < 0) {
1817                 dev_err(nor->dev,
1818                         "error while writing configuration register\n");
1819                 return -EINVAL;
1820         }
1821
1822         ret = spi_nor_wait_till_ready(nor);
1823         if (ret) {
1824                 dev_err(nor->dev,
1825                         "timeout while writing configuration register\n");
1826                 return ret;
1827         }
1828
1829         return 0;
1830 }
1831
1832 /**
1833  * spansion_quad_enable() - set QE bit in Configuraiton Register.
1834  * @nor:        pointer to a 'struct spi_nor'
1835  *
1836  * Set the Quad Enable (QE) bit in the Configuration Register.
1837  * This function is kept for legacy purpose because it has been used for a
1838  * long time without anybody complaining but it should be considered as
1839  * deprecated and maybe buggy.
1840  * First, this function doesn't care about the previous values of the Status
1841  * and Configuration Registers when it sets the QE bit (bit 1) in the
1842  * Configuration Register: all other bits are cleared, which may have unwanted
1843  * side effects like removing some block protections.
1844  * Secondly, it uses the Read Configuration Register (35h) instruction though
1845  * some very old and few memories don't support this instruction. If a pull-up
1846  * resistor is present on the MISO/IO1 line, we might still be able to pass the
1847  * "read back" test because the QSPI memory doesn't recognize the command,
1848  * so leaves the MISO/IO1 line state unchanged, hence read_cr() returns 0xFF.
1849  *
1850  * bit 1 of the Configuration Register is the QE bit for Spansion like QSPI
1851  * memories.
1852  *
1853  * Return: 0 on success, -errno otherwise.
1854  */
1855 static int spansion_quad_enable(struct spi_nor *nor)
1856 {
1857         u8 sr_cr[2] = {0, CR_QUAD_EN_SPAN};
1858         int ret;
1859
1860         ret = write_sr_cr(nor, sr_cr);
1861         if (ret)
1862                 return ret;
1863
1864         /* read back and check it */
1865         ret = read_cr(nor);
1866         if (!(ret > 0 && (ret & CR_QUAD_EN_SPAN))) {
1867                 dev_err(nor->dev, "Spansion Quad bit not set\n");
1868                 return -EINVAL;
1869         }
1870
1871         return 0;
1872 }
1873
1874 /**
1875  * spansion_no_read_cr_quad_enable() - set QE bit in Configuration Register.
1876  * @nor:        pointer to a 'struct spi_nor'
1877  *
1878  * Set the Quad Enable (QE) bit in the Configuration Register.
1879  * This function should be used with QSPI memories not supporting the Read
1880  * Configuration Register (35h) instruction.
1881  *
1882  * bit 1 of the Configuration Register is the QE bit for Spansion like QSPI
1883  * memories.
1884  *
1885  * Return: 0 on success, -errno otherwise.
1886  */
1887 static int spansion_no_read_cr_quad_enable(struct spi_nor *nor)
1888 {
1889         u8 sr_cr[2];
1890         int ret;
1891
1892         /* Keep the current value of the Status Register. */
1893         ret = read_sr(nor);
1894         if (ret < 0) {
1895                 dev_err(nor->dev, "error while reading status register\n");
1896                 return -EINVAL;
1897         }
1898         sr_cr[0] = ret;
1899         sr_cr[1] = CR_QUAD_EN_SPAN;
1900
1901         return write_sr_cr(nor, sr_cr);
1902 }
1903
1904 /**
1905  * spansion_read_cr_quad_enable() - set QE bit in Configuration Register.
1906  * @nor:        pointer to a 'struct spi_nor'
1907  *
1908  * Set the Quad Enable (QE) bit in the Configuration Register.
1909  * This function should be used with QSPI memories supporting the Read
1910  * Configuration Register (35h) instruction.
1911  *
1912  * bit 1 of the Configuration Register is the QE bit for Spansion like QSPI
1913  * memories.
1914  *
1915  * Return: 0 on success, -errno otherwise.
1916  */
1917 static int spansion_read_cr_quad_enable(struct spi_nor *nor)
1918 {
1919         struct device *dev = nor->dev;
1920         u8 sr_cr[2];
1921         int ret;
1922
1923         /* Check current Quad Enable bit value. */
1924         ret = read_cr(nor);
1925         if (ret < 0) {
1926                 dev_err(dev, "error while reading configuration register\n");
1927                 return -EINVAL;
1928         }
1929
1930         if (ret & CR_QUAD_EN_SPAN)
1931                 return 0;
1932
1933         sr_cr[1] = ret | CR_QUAD_EN_SPAN;
1934
1935         /* Keep the current value of the Status Register. */
1936         ret = read_sr(nor);
1937         if (ret < 0) {
1938                 dev_err(dev, "error while reading status register\n");
1939                 return -EINVAL;
1940         }
1941         sr_cr[0] = ret;
1942
1943         ret = write_sr_cr(nor, sr_cr);
1944         if (ret)
1945                 return ret;
1946
1947         /* Read back and check it. */
1948         ret = read_cr(nor);
1949         if (!(ret > 0 && (ret & CR_QUAD_EN_SPAN))) {
1950                 dev_err(nor->dev, "Spansion Quad bit not set\n");
1951                 return -EINVAL;
1952         }
1953
1954         return 0;
1955 }
1956
1957 /**
1958  * sr2_bit7_quad_enable() - set QE bit in Status Register 2.
1959  * @nor:        pointer to a 'struct spi_nor'
1960  *
1961  * Set the Quad Enable (QE) bit in the Status Register 2.
1962  *
1963  * This is one of the procedures to set the QE bit described in the SFDP
1964  * (JESD216 rev B) specification but no manufacturer using this procedure has
1965  * been identified yet, hence the name of the function.
1966  *
1967  * Return: 0 on success, -errno otherwise.
1968  */
1969 static int sr2_bit7_quad_enable(struct spi_nor *nor)
1970 {
1971         u8 sr2;
1972         int ret;
1973
1974         /* Check current Quad Enable bit value. */
1975         ret = nor->read_reg(nor, SPINOR_OP_RDSR2, &sr2, 1);
1976         if (ret)
1977                 return ret;
1978         if (sr2 & SR2_QUAD_EN_BIT7)
1979                 return 0;
1980
1981         /* Update the Quad Enable bit. */
1982         sr2 |= SR2_QUAD_EN_BIT7;
1983
1984         write_enable(nor);
1985
1986         ret = nor->write_reg(nor, SPINOR_OP_WRSR2, &sr2, 1);
1987         if (ret < 0) {
1988                 dev_err(nor->dev, "error while writing status register 2\n");
1989                 return -EINVAL;
1990         }
1991
1992         ret = spi_nor_wait_till_ready(nor);
1993         if (ret < 0) {
1994                 dev_err(nor->dev, "timeout while writing status register 2\n");
1995                 return ret;
1996         }
1997
1998         /* Read back and check it. */
1999         ret = nor->read_reg(nor, SPINOR_OP_RDSR2, &sr2, 1);
2000         if (!(ret > 0 && (sr2 & SR2_QUAD_EN_BIT7))) {
2001                 dev_err(nor->dev, "SR2 Quad bit not set\n");
2002                 return -EINVAL;
2003         }
2004
2005         return 0;
2006 }
2007
2008 static int spi_nor_check(struct spi_nor *nor)
2009 {
2010         if (!nor->dev || !nor->read || !nor->write ||
2011                 !nor->read_reg || !nor->write_reg) {
2012                 pr_err("spi-nor: please fill all the necessary fields!\n");
2013                 return -EINVAL;
2014         }
2015
2016         return 0;
2017 }
2018
2019 static int s3an_nor_scan(const struct flash_info *info, struct spi_nor *nor)
2020 {
2021         int ret;
2022         u8 val;
2023
2024         ret = nor->read_reg(nor, SPINOR_OP_XRDSR, &val, 1);
2025         if (ret < 0) {
2026                 dev_err(nor->dev, "error %d reading XRDSR\n", (int) ret);
2027                 return ret;
2028         }
2029
2030         nor->erase_opcode = SPINOR_OP_XSE;
2031         nor->program_opcode = SPINOR_OP_XPP;
2032         nor->read_opcode = SPINOR_OP_READ;
2033         nor->flags |= SNOR_F_NO_OP_CHIP_ERASE;
2034
2035         /*
2036          * This flashes have a page size of 264 or 528 bytes (known as
2037          * Default addressing mode). It can be changed to a more standard
2038          * Power of two mode where the page size is 256/512. This comes
2039          * with a price: there is 3% less of space, the data is corrupted
2040          * and the page size cannot be changed back to default addressing
2041          * mode.
2042          *
2043          * The current addressing mode can be read from the XRDSR register
2044          * and should not be changed, because is a destructive operation.
2045          */
2046         if (val & XSR_PAGESIZE) {
2047                 /* Flash in Power of 2 mode */
2048                 nor->page_size = (nor->page_size == 264) ? 256 : 512;
2049                 nor->mtd.writebufsize = nor->page_size;
2050                 nor->mtd.size = 8 * nor->page_size * info->n_sectors;
2051                 nor->mtd.erasesize = 8 * nor->page_size;
2052         } else {
2053                 /* Flash in Default addressing mode */
2054                 nor->flags |= SNOR_F_S3AN_ADDR_DEFAULT;
2055         }
2056
2057         return 0;
2058 }
2059
2060 struct spi_nor_read_command {
2061         u8                      num_mode_clocks;
2062         u8                      num_wait_states;
2063         u8                      opcode;
2064         enum spi_nor_protocol   proto;
2065 };
2066
2067 struct spi_nor_pp_command {
2068         u8                      opcode;
2069         enum spi_nor_protocol   proto;
2070 };
2071
2072 enum spi_nor_read_command_index {
2073         SNOR_CMD_READ,
2074         SNOR_CMD_READ_FAST,
2075         SNOR_CMD_READ_1_1_1_DTR,
2076
2077         /* Dual SPI */
2078         SNOR_CMD_READ_1_1_2,
2079         SNOR_CMD_READ_1_2_2,
2080         SNOR_CMD_READ_2_2_2,
2081         SNOR_CMD_READ_1_2_2_DTR,
2082
2083         /* Quad SPI */
2084         SNOR_CMD_READ_1_1_4,
2085         SNOR_CMD_READ_1_4_4,
2086         SNOR_CMD_READ_4_4_4,
2087         SNOR_CMD_READ_1_4_4_DTR,
2088
2089         /* Octo SPI */
2090         SNOR_CMD_READ_1_1_8,
2091         SNOR_CMD_READ_1_8_8,
2092         SNOR_CMD_READ_8_8_8,
2093         SNOR_CMD_READ_1_8_8_DTR,
2094
2095         SNOR_CMD_READ_MAX
2096 };
2097
2098 enum spi_nor_pp_command_index {
2099         SNOR_CMD_PP,
2100
2101         /* Quad SPI */
2102         SNOR_CMD_PP_1_1_4,
2103         SNOR_CMD_PP_1_4_4,
2104         SNOR_CMD_PP_4_4_4,
2105
2106         /* Octo SPI */
2107         SNOR_CMD_PP_1_1_8,
2108         SNOR_CMD_PP_1_8_8,
2109         SNOR_CMD_PP_8_8_8,
2110
2111         SNOR_CMD_PP_MAX
2112 };
2113
2114 struct spi_nor_flash_parameter {
2115         u64                             size;
2116         u32                             page_size;
2117
2118         struct spi_nor_hwcaps           hwcaps;
2119         struct spi_nor_read_command     reads[SNOR_CMD_READ_MAX];
2120         struct spi_nor_pp_command       page_programs[SNOR_CMD_PP_MAX];
2121
2122         int (*quad_enable)(struct spi_nor *nor);
2123 };
2124
2125 static void
2126 spi_nor_set_read_settings(struct spi_nor_read_command *read,
2127                           u8 num_mode_clocks,
2128                           u8 num_wait_states,
2129                           u8 opcode,
2130                           enum spi_nor_protocol proto)
2131 {
2132         read->num_mode_clocks = num_mode_clocks;
2133         read->num_wait_states = num_wait_states;
2134         read->opcode = opcode;
2135         read->proto = proto;
2136 }
2137
2138 static void
2139 spi_nor_set_pp_settings(struct spi_nor_pp_command *pp,
2140                         u8 opcode,
2141                         enum spi_nor_protocol proto)
2142 {
2143         pp->opcode = opcode;
2144         pp->proto = proto;
2145 }
2146
2147 /*
2148  * Serial Flash Discoverable Parameters (SFDP) parsing.
2149  */
2150
2151 /**
2152  * spi_nor_read_raw() - raw read of serial flash memory. read_opcode,
2153  *                      addr_width and read_dummy members of the struct spi_nor
2154  *                      should be previously
2155  * set.
2156  * @nor:        pointer to a 'struct spi_nor'
2157  * @addr:       offset in the serial flash memory
2158  * @len:        number of bytes to read
2159  * @buf:        buffer where the data is copied into
2160  *
2161  * Return: 0 on success, -errno otherwise.
2162  */
2163 static int spi_nor_read_raw(struct spi_nor *nor, u32 addr, size_t len, u8 *buf)
2164 {
2165         int ret;
2166
2167         while (len) {
2168                 ret = nor->read(nor, addr, len, buf);
2169                 if (!ret || ret > len)
2170                         return -EIO;
2171                 if (ret < 0)
2172                         return ret;
2173
2174                 buf += ret;
2175                 addr += ret;
2176                 len -= ret;
2177         }
2178         return 0;
2179 }
2180
2181 /**
2182  * spi_nor_read_sfdp() - read Serial Flash Discoverable Parameters.
2183  * @nor:        pointer to a 'struct spi_nor'
2184  * @addr:       offset in the SFDP area to start reading data from
2185  * @len:        number of bytes to read
2186  * @buf:        buffer where the SFDP data are copied into (dma-safe memory)
2187  *
2188  * Whatever the actual numbers of bytes for address and dummy cycles are
2189  * for (Fast) Read commands, the Read SFDP (5Ah) instruction is always
2190  * followed by a 3-byte address and 8 dummy clock cycles.
2191  *
2192  * Return: 0 on success, -errno otherwise.
2193  */
2194 static int spi_nor_read_sfdp(struct spi_nor *nor, u32 addr,
2195                              size_t len, void *buf)
2196 {
2197         u8 addr_width, read_opcode, read_dummy;
2198         int ret;
2199
2200         read_opcode = nor->read_opcode;
2201         addr_width = nor->addr_width;
2202         read_dummy = nor->read_dummy;
2203
2204         nor->read_opcode = SPINOR_OP_RDSFDP;
2205         nor->addr_width = 3;
2206         nor->read_dummy = 8;
2207
2208         ret = spi_nor_read_raw(nor, addr, len, buf);
2209
2210         nor->read_opcode = read_opcode;
2211         nor->addr_width = addr_width;
2212         nor->read_dummy = read_dummy;
2213
2214         return ret;
2215 }
2216
2217 /**
2218  * spi_nor_read_sfdp_dma_unsafe() - read Serial Flash Discoverable Parameters.
2219  * @nor:        pointer to a 'struct spi_nor'
2220  * @addr:       offset in the SFDP area to start reading data from
2221  * @len:        number of bytes to read
2222  * @buf:        buffer where the SFDP data are copied into
2223  *
2224  * Wrap spi_nor_read_sfdp() using a kmalloc'ed bounce buffer as @buf is now not
2225  * guaranteed to be dma-safe.
2226  *
2227  * Return: -ENOMEM if kmalloc() fails, the return code of spi_nor_read_sfdp()
2228  *          otherwise.
2229  */
2230 static int spi_nor_read_sfdp_dma_unsafe(struct spi_nor *nor, u32 addr,
2231                                         size_t len, void *buf)
2232 {
2233         void *dma_safe_buf;
2234         int ret;
2235
2236         dma_safe_buf = kmalloc(len, GFP_KERNEL);
2237         if (!dma_safe_buf)
2238                 return -ENOMEM;
2239
2240         ret = spi_nor_read_sfdp(nor, addr, len, dma_safe_buf);
2241         memcpy(buf, dma_safe_buf, len);
2242         kfree(dma_safe_buf);
2243
2244         return ret;
2245 }
2246
2247 struct sfdp_parameter_header {
2248         u8              id_lsb;
2249         u8              minor;
2250         u8              major;
2251         u8              length; /* in double words */
2252         u8              parameter_table_pointer[3]; /* byte address */
2253         u8              id_msb;
2254 };
2255
2256 #define SFDP_PARAM_HEADER_ID(p) (((p)->id_msb << 8) | (p)->id_lsb)
2257 #define SFDP_PARAM_HEADER_PTP(p) \
2258         (((p)->parameter_table_pointer[2] << 16) | \
2259          ((p)->parameter_table_pointer[1] <<  8) | \
2260          ((p)->parameter_table_pointer[0] <<  0))
2261
2262 #define SFDP_BFPT_ID            0xff00  /* Basic Flash Parameter Table */
2263 #define SFDP_SECTOR_MAP_ID      0xff81  /* Sector Map Table */
2264
2265 #define SFDP_SIGNATURE          0x50444653U
2266 #define SFDP_JESD216_MAJOR      1
2267 #define SFDP_JESD216_MINOR      0
2268 #define SFDP_JESD216A_MINOR     5
2269 #define SFDP_JESD216B_MINOR     6
2270
2271 struct sfdp_header {
2272         u32             signature; /* Ox50444653U <=> "SFDP" */
2273         u8              minor;
2274         u8              major;
2275         u8              nph; /* 0-base number of parameter headers */
2276         u8              unused;
2277
2278         /* Basic Flash Parameter Table. */
2279         struct sfdp_parameter_header    bfpt_header;
2280 };
2281
2282 /* Basic Flash Parameter Table */
2283
2284 /*
2285  * JESD216 rev B defines a Basic Flash Parameter Table of 16 DWORDs.
2286  * They are indexed from 1 but C arrays are indexed from 0.
2287  */
2288 #define BFPT_DWORD(i)           ((i) - 1)
2289 #define BFPT_DWORD_MAX          16
2290
2291 /* The first version of JESB216 defined only 9 DWORDs. */
2292 #define BFPT_DWORD_MAX_JESD216                  9
2293
2294 /* 1st DWORD. */
2295 #define BFPT_DWORD1_FAST_READ_1_1_2             BIT(16)
2296 #define BFPT_DWORD1_ADDRESS_BYTES_MASK          GENMASK(18, 17)
2297 #define BFPT_DWORD1_ADDRESS_BYTES_3_ONLY        (0x0UL << 17)
2298 #define BFPT_DWORD1_ADDRESS_BYTES_3_OR_4        (0x1UL << 17)
2299 #define BFPT_DWORD1_ADDRESS_BYTES_4_ONLY        (0x2UL << 17)
2300 #define BFPT_DWORD1_DTR                         BIT(19)
2301 #define BFPT_DWORD1_FAST_READ_1_2_2             BIT(20)
2302 #define BFPT_DWORD1_FAST_READ_1_4_4             BIT(21)
2303 #define BFPT_DWORD1_FAST_READ_1_1_4             BIT(22)
2304
2305 /* 5th DWORD. */
2306 #define BFPT_DWORD5_FAST_READ_2_2_2             BIT(0)
2307 #define BFPT_DWORD5_FAST_READ_4_4_4             BIT(4)
2308
2309 /* 11th DWORD. */
2310 #define BFPT_DWORD11_PAGE_SIZE_SHIFT            4
2311 #define BFPT_DWORD11_PAGE_SIZE_MASK             GENMASK(7, 4)
2312
2313 /* 15th DWORD. */
2314
2315 /*
2316  * (from JESD216 rev B)
2317  * Quad Enable Requirements (QER):
2318  * - 000b: Device does not have a QE bit. Device detects 1-1-4 and 1-4-4
2319  *         reads based on instruction. DQ3/HOLD# functions are hold during
2320  *         instruction phase.
2321  * - 001b: QE is bit 1 of status register 2. It is set via Write Status with
2322  *         two data bytes where bit 1 of the second byte is one.
2323  *         [...]
2324  *         Writing only one byte to the status register has the side-effect of
2325  *         clearing status register 2, including the QE bit. The 100b code is
2326  *         used if writing one byte to the status register does not modify
2327  *         status register 2.
2328  * - 010b: QE is bit 6 of status register 1. It is set via Write Status with
2329  *         one data byte where bit 6 is one.
2330  *         [...]
2331  * - 011b: QE is bit 7 of status register 2. It is set via Write status
2332  *         register 2 instruction 3Eh with one data byte where bit 7 is one.
2333  *         [...]
2334  *         The status register 2 is read using instruction 3Fh.
2335  * - 100b: QE is bit 1 of status register 2. It is set via Write Status with
2336  *         two data bytes where bit 1 of the second byte is one.
2337  *         [...]
2338  *         In contrast to the 001b code, writing one byte to the status
2339  *         register does not modify status register 2.
2340  * - 101b: QE is bit 1 of status register 2. Status register 1 is read using
2341  *         Read Status instruction 05h. Status register2 is read using
2342  *         instruction 35h. QE is set via Writ Status instruction 01h with
2343  *         two data bytes where bit 1 of the second byte is one.
2344  *         [...]
2345  */
2346 #define BFPT_DWORD15_QER_MASK                   GENMASK(22, 20)
2347 #define BFPT_DWORD15_QER_NONE                   (0x0UL << 20) /* Micron */
2348 #define BFPT_DWORD15_QER_SR2_BIT1_BUGGY         (0x1UL << 20)
2349 #define BFPT_DWORD15_QER_SR1_BIT6               (0x2UL << 20) /* Macronix */
2350 #define BFPT_DWORD15_QER_SR2_BIT7               (0x3UL << 20)
2351 #define BFPT_DWORD15_QER_SR2_BIT1_NO_RD         (0x4UL << 20)
2352 #define BFPT_DWORD15_QER_SR2_BIT1               (0x5UL << 20) /* Spansion */
2353
2354 struct sfdp_bfpt {
2355         u32     dwords[BFPT_DWORD_MAX];
2356 };
2357
2358 /* Fast Read settings. */
2359
2360 static inline void
2361 spi_nor_set_read_settings_from_bfpt(struct spi_nor_read_command *read,
2362                                     u16 half,
2363                                     enum spi_nor_protocol proto)
2364 {
2365         read->num_mode_clocks = (half >> 5) & 0x07;
2366         read->num_wait_states = (half >> 0) & 0x1f;
2367         read->opcode = (half >> 8) & 0xff;
2368         read->proto = proto;
2369 }
2370
2371 struct sfdp_bfpt_read {
2372         /* The Fast Read x-y-z hardware capability in params->hwcaps.mask. */
2373         u32                     hwcaps;
2374
2375         /*
2376          * The <supported_bit> bit in <supported_dword> BFPT DWORD tells us
2377          * whether the Fast Read x-y-z command is supported.
2378          */
2379         u32                     supported_dword;
2380         u32                     supported_bit;
2381
2382         /*
2383          * The half-word at offset <setting_shift> in <setting_dword> BFPT DWORD
2384          * encodes the op code, the number of mode clocks and the number of wait
2385          * states to be used by Fast Read x-y-z command.
2386          */
2387         u32                     settings_dword;
2388         u32                     settings_shift;
2389
2390         /* The SPI protocol for this Fast Read x-y-z command. */
2391         enum spi_nor_protocol   proto;
2392 };
2393
2394 static const struct sfdp_bfpt_read sfdp_bfpt_reads[] = {
2395         /* Fast Read 1-1-2 */
2396         {
2397                 SNOR_HWCAPS_READ_1_1_2,
2398                 BFPT_DWORD(1), BIT(16), /* Supported bit */
2399                 BFPT_DWORD(4), 0,       /* Settings */
2400                 SNOR_PROTO_1_1_2,
2401         },
2402
2403         /* Fast Read 1-2-2 */
2404         {
2405                 SNOR_HWCAPS_READ_1_2_2,
2406                 BFPT_DWORD(1), BIT(20), /* Supported bit */
2407                 BFPT_DWORD(4), 16,      /* Settings */
2408                 SNOR_PROTO_1_2_2,
2409         },
2410
2411         /* Fast Read 2-2-2 */
2412         {
2413                 SNOR_HWCAPS_READ_2_2_2,
2414                 BFPT_DWORD(5),  BIT(0), /* Supported bit */
2415                 BFPT_DWORD(6), 16,      /* Settings */
2416                 SNOR_PROTO_2_2_2,
2417         },
2418
2419         /* Fast Read 1-1-4 */
2420         {
2421                 SNOR_HWCAPS_READ_1_1_4,
2422                 BFPT_DWORD(1), BIT(22), /* Supported bit */
2423                 BFPT_DWORD(3), 16,      /* Settings */
2424                 SNOR_PROTO_1_1_4,
2425         },
2426
2427         /* Fast Read 1-4-4 */
2428         {
2429                 SNOR_HWCAPS_READ_1_4_4,
2430                 BFPT_DWORD(1), BIT(21), /* Supported bit */
2431                 BFPT_DWORD(3), 0,       /* Settings */
2432                 SNOR_PROTO_1_4_4,
2433         },
2434
2435         /* Fast Read 4-4-4 */
2436         {
2437                 SNOR_HWCAPS_READ_4_4_4,
2438                 BFPT_DWORD(5), BIT(4),  /* Supported bit */
2439                 BFPT_DWORD(7), 16,      /* Settings */
2440                 SNOR_PROTO_4_4_4,
2441         },
2442 };
2443
2444 struct sfdp_bfpt_erase {
2445         /*
2446          * The half-word at offset <shift> in DWORD <dwoard> encodes the
2447          * op code and erase sector size to be used by Sector Erase commands.
2448          */
2449         u32                     dword;
2450         u32                     shift;
2451 };
2452
2453 static const struct sfdp_bfpt_erase sfdp_bfpt_erases[] = {
2454         /* Erase Type 1 in DWORD8 bits[15:0] */
2455         {BFPT_DWORD(8), 0},
2456
2457         /* Erase Type 2 in DWORD8 bits[31:16] */
2458         {BFPT_DWORD(8), 16},
2459
2460         /* Erase Type 3 in DWORD9 bits[15:0] */
2461         {BFPT_DWORD(9), 0},
2462
2463         /* Erase Type 4 in DWORD9 bits[31:16] */
2464         {BFPT_DWORD(9), 16},
2465 };
2466
2467 static int spi_nor_hwcaps_read2cmd(u32 hwcaps);
2468
2469 /**
2470  * spi_nor_set_erase_type() - set a SPI NOR erase type
2471  * @erase:      pointer to a structure that describes a SPI NOR erase type
2472  * @size:       the size of the sector/block erased by the erase type
2473  * @opcode:     the SPI command op code to erase the sector/block
2474  */
2475 static void spi_nor_set_erase_type(struct spi_nor_erase_type *erase,
2476                                    u32 size, u8 opcode)
2477 {
2478         erase->size = size;
2479         erase->opcode = opcode;
2480         /* JEDEC JESD216B Standard imposes erase sizes to be power of 2. */
2481         erase->size_shift = ffs(erase->size) - 1;
2482         erase->size_mask = (1 << erase->size_shift) - 1;
2483 }
2484
2485 /**
2486  * spi_nor_set_erase_settings_from_bfpt() - set erase type settings from BFPT
2487  * @erase:      pointer to a structure that describes a SPI NOR erase type
2488  * @size:       the size of the sector/block erased by the erase type
2489  * @opcode:     the SPI command op code to erase the sector/block
2490  * @i:          erase type index as sorted in the Basic Flash Parameter Table
2491  *
2492  * The supported Erase Types will be sorted at init in ascending order, with
2493  * the smallest Erase Type size being the first member in the erase_type array
2494  * of the spi_nor_erase_map structure. Save the Erase Type index as sorted in
2495  * the Basic Flash Parameter Table since it will be used later on to
2496  * synchronize with the supported Erase Types defined in SFDP optional tables.
2497  */
2498 static void
2499 spi_nor_set_erase_settings_from_bfpt(struct spi_nor_erase_type *erase,
2500                                      u32 size, u8 opcode, u8 i)
2501 {
2502         erase->idx = i;
2503         spi_nor_set_erase_type(erase, size, opcode);
2504 }
2505
2506 /**
2507  * spi_nor_map_cmp_erase_type() - compare the map's erase types by size
2508  * @l:  member in the left half of the map's erase_type array
2509  * @r:  member in the right half of the map's erase_type array
2510  *
2511  * Comparison function used in the sort() call to sort in ascending order the
2512  * map's erase types, the smallest erase type size being the first member in the
2513  * sorted erase_type array.
2514  *
2515  * Return: the result of @l->size - @r->size
2516  */
2517 static int spi_nor_map_cmp_erase_type(const void *l, const void *r)
2518 {
2519         const struct spi_nor_erase_type *left = l, *right = r;
2520
2521         return left->size - right->size;
2522 }
2523
2524 /**
2525  * spi_nor_regions_sort_erase_types() - sort erase types in each region
2526  * @map:        the erase map of the SPI NOR
2527  *
2528  * Function assumes that the erase types defined in the erase map are already
2529  * sorted in ascending order, with the smallest erase type size being the first
2530  * member in the erase_type array. It replicates the sort done for the map's
2531  * erase types. Each region's erase bitmask will indicate which erase types are
2532  * supported from the sorted erase types defined in the erase map.
2533  * Sort the all region's erase type at init in order to speed up the process of
2534  * finding the best erase command at runtime.
2535  */
2536 static void spi_nor_regions_sort_erase_types(struct spi_nor_erase_map *map)
2537 {
2538         struct spi_nor_erase_region *region = map->regions;
2539         struct spi_nor_erase_type *erase_type = map->erase_type;
2540         int i;
2541         u8 region_erase_mask, sorted_erase_mask;
2542
2543         while (region) {
2544                 region_erase_mask = region->offset & SNOR_ERASE_TYPE_MASK;
2545
2546                 /* Replicate the sort done for the map's erase types. */
2547                 sorted_erase_mask = 0;
2548                 for (i = 0; i < SNOR_ERASE_TYPE_MAX; i++)
2549                         if (erase_type[i].size &&
2550                             region_erase_mask & BIT(erase_type[i].idx))
2551                                 sorted_erase_mask |= BIT(i);
2552
2553                 /* Overwrite erase mask. */
2554                 region->offset = (region->offset & ~SNOR_ERASE_TYPE_MASK) |
2555                                  sorted_erase_mask;
2556
2557                 region = spi_nor_region_next(region);
2558         }
2559 }
2560
2561 /**
2562  * spi_nor_init_uniform_erase_map() - Initialize uniform erase map
2563  * @map:                the erase map of the SPI NOR
2564  * @erase_mask:         bitmask encoding erase types that can erase the entire
2565  *                      flash memory
2566  * @flash_size:         the spi nor flash memory size
2567  */
2568 static void spi_nor_init_uniform_erase_map(struct spi_nor_erase_map *map,
2569                                            u8 erase_mask, u64 flash_size)
2570 {
2571         /* Offset 0 with erase_mask and SNOR_LAST_REGION bit set */
2572         map->uniform_region.offset = (erase_mask & SNOR_ERASE_TYPE_MASK) |
2573                                      SNOR_LAST_REGION;
2574         map->uniform_region.size = flash_size;
2575         map->regions = &map->uniform_region;
2576         map->uniform_erase_type = erase_mask;
2577 }
2578
2579 /**
2580  * spi_nor_parse_bfpt() - read and parse the Basic Flash Parameter Table.
2581  * @nor:                pointer to a 'struct spi_nor'
2582  * @bfpt_header:        pointer to the 'struct sfdp_parameter_header' describing
2583  *                      the Basic Flash Parameter Table length and version
2584  * @params:             pointer to the 'struct spi_nor_flash_parameter' to be
2585  *                      filled
2586  *
2587  * The Basic Flash Parameter Table is the main and only mandatory table as
2588  * defined by the SFDP (JESD216) specification.
2589  * It provides us with the total size (memory density) of the data array and
2590  * the number of address bytes for Fast Read, Page Program and Sector Erase
2591  * commands.
2592  * For Fast READ commands, it also gives the number of mode clock cycles and
2593  * wait states (regrouped in the number of dummy clock cycles) for each
2594  * supported instruction op code.
2595  * For Page Program, the page size is now available since JESD216 rev A, however
2596  * the supported instruction op codes are still not provided.
2597  * For Sector Erase commands, this table stores the supported instruction op
2598  * codes and the associated sector sizes.
2599  * Finally, the Quad Enable Requirements (QER) are also available since JESD216
2600  * rev A. The QER bits encode the manufacturer dependent procedure to be
2601  * executed to set the Quad Enable (QE) bit in some internal register of the
2602  * Quad SPI memory. Indeed the QE bit, when it exists, must be set before
2603  * sending any Quad SPI command to the memory. Actually, setting the QE bit
2604  * tells the memory to reassign its WP# and HOLD#/RESET# pins to functions IO2
2605  * and IO3 hence enabling 4 (Quad) I/O lines.
2606  *
2607  * Return: 0 on success, -errno otherwise.
2608  */
2609 static int spi_nor_parse_bfpt(struct spi_nor *nor,
2610                               const struct sfdp_parameter_header *bfpt_header,
2611                               struct spi_nor_flash_parameter *params)
2612 {
2613         struct spi_nor_erase_map *map = &nor->erase_map;
2614         struct spi_nor_erase_type *erase_type = map->erase_type;
2615         struct sfdp_bfpt bfpt;
2616         size_t len;
2617         int i, cmd, err;
2618         u32 addr;
2619         u16 half;
2620         u8 erase_mask;
2621
2622         /* JESD216 Basic Flash Parameter Table length is at least 9 DWORDs. */
2623         if (bfpt_header->length < BFPT_DWORD_MAX_JESD216)
2624                 return -EINVAL;
2625
2626         /* Read the Basic Flash Parameter Table. */
2627         len = min_t(size_t, sizeof(bfpt),
2628                     bfpt_header->length * sizeof(u32));
2629         addr = SFDP_PARAM_HEADER_PTP(bfpt_header);
2630         memset(&bfpt, 0, sizeof(bfpt));
2631         err = spi_nor_read_sfdp_dma_unsafe(nor,  addr, len, &bfpt);
2632         if (err < 0)
2633                 return err;
2634
2635         /* Fix endianness of the BFPT DWORDs. */
2636         for (i = 0; i < BFPT_DWORD_MAX; i++)
2637                 bfpt.dwords[i] = le32_to_cpu(bfpt.dwords[i]);
2638
2639         /* Number of address bytes. */
2640         switch (bfpt.dwords[BFPT_DWORD(1)] & BFPT_DWORD1_ADDRESS_BYTES_MASK) {
2641         case BFPT_DWORD1_ADDRESS_BYTES_3_ONLY:
2642                 nor->addr_width = 3;
2643                 break;
2644
2645         case BFPT_DWORD1_ADDRESS_BYTES_4_ONLY:
2646                 nor->addr_width = 4;
2647                 break;
2648
2649         default:
2650                 break;
2651         }
2652
2653         /* Flash Memory Density (in bits). */
2654         params->size = bfpt.dwords[BFPT_DWORD(2)];
2655         if (params->size & BIT(31)) {
2656                 params->size &= ~BIT(31);
2657
2658                 /*
2659                  * Prevent overflows on params->size. Anyway, a NOR of 2^64
2660                  * bits is unlikely to exist so this error probably means
2661                  * the BFPT we are reading is corrupted/wrong.
2662                  */
2663                 if (params->size > 63)
2664                         return -EINVAL;
2665
2666                 params->size = 1ULL << params->size;
2667         } else {
2668                 params->size++;
2669         }
2670         params->size >>= 3; /* Convert to bytes. */
2671
2672         /* Fast Read settings. */
2673         for (i = 0; i < ARRAY_SIZE(sfdp_bfpt_reads); i++) {
2674                 const struct sfdp_bfpt_read *rd = &sfdp_bfpt_reads[i];
2675                 struct spi_nor_read_command *read;
2676
2677                 if (!(bfpt.dwords[rd->supported_dword] & rd->supported_bit)) {
2678                         params->hwcaps.mask &= ~rd->hwcaps;
2679                         continue;
2680                 }
2681
2682                 params->hwcaps.mask |= rd->hwcaps;
2683                 cmd = spi_nor_hwcaps_read2cmd(rd->hwcaps);
2684                 read = &params->reads[cmd];
2685                 half = bfpt.dwords[rd->settings_dword] >> rd->settings_shift;
2686                 spi_nor_set_read_settings_from_bfpt(read, half, rd->proto);
2687         }
2688
2689         /*
2690          * Sector Erase settings. Reinitialize the uniform erase map using the
2691          * Erase Types defined in the bfpt table.
2692          */
2693         erase_mask = 0;
2694         memset(&nor->erase_map, 0, sizeof(nor->erase_map));
2695         for (i = 0; i < ARRAY_SIZE(sfdp_bfpt_erases); i++) {
2696                 const struct sfdp_bfpt_erase *er = &sfdp_bfpt_erases[i];
2697                 u32 erasesize;
2698                 u8 opcode;
2699
2700                 half = bfpt.dwords[er->dword] >> er->shift;
2701                 erasesize = half & 0xff;
2702
2703                 /* erasesize == 0 means this Erase Type is not supported. */
2704                 if (!erasesize)
2705                         continue;
2706
2707                 erasesize = 1U << erasesize;
2708                 opcode = (half >> 8) & 0xff;
2709                 erase_mask |= BIT(i);
2710                 spi_nor_set_erase_settings_from_bfpt(&erase_type[i], erasesize,
2711                                                      opcode, i);
2712         }
2713         spi_nor_init_uniform_erase_map(map, erase_mask, params->size);
2714         /*
2715          * Sort all the map's Erase Types in ascending order with the smallest
2716          * erase size being the first member in the erase_type array.
2717          */
2718         sort(erase_type, SNOR_ERASE_TYPE_MAX, sizeof(erase_type[0]),
2719              spi_nor_map_cmp_erase_type, NULL);
2720         /*
2721          * Sort the erase types in the uniform region in order to update the
2722          * uniform_erase_type bitmask. The bitmask will be used later on when
2723          * selecting the uniform erase.
2724          */
2725         spi_nor_regions_sort_erase_types(map);
2726         map->uniform_erase_type = map->uniform_region.offset &
2727                                   SNOR_ERASE_TYPE_MASK;
2728
2729         /* Stop here if not JESD216 rev A or later. */
2730         if (bfpt_header->length < BFPT_DWORD_MAX)
2731                 return 0;
2732
2733         /* Page size: this field specifies 'N' so the page size = 2^N bytes. */
2734         params->page_size = bfpt.dwords[BFPT_DWORD(11)];
2735         params->page_size &= BFPT_DWORD11_PAGE_SIZE_MASK;
2736         params->page_size >>= BFPT_DWORD11_PAGE_SIZE_SHIFT;
2737         params->page_size = 1U << params->page_size;
2738
2739         /* Quad Enable Requirements. */
2740         switch (bfpt.dwords[BFPT_DWORD(15)] & BFPT_DWORD15_QER_MASK) {
2741         case BFPT_DWORD15_QER_NONE:
2742                 params->quad_enable = NULL;
2743                 break;
2744
2745         case BFPT_DWORD15_QER_SR2_BIT1_BUGGY:
2746         case BFPT_DWORD15_QER_SR2_BIT1_NO_RD:
2747                 params->quad_enable = spansion_no_read_cr_quad_enable;
2748                 break;
2749
2750         case BFPT_DWORD15_QER_SR1_BIT6:
2751                 params->quad_enable = macronix_quad_enable;
2752                 break;
2753
2754         case BFPT_DWORD15_QER_SR2_BIT7:
2755                 params->quad_enable = sr2_bit7_quad_enable;
2756                 break;
2757
2758         case BFPT_DWORD15_QER_SR2_BIT1:
2759                 params->quad_enable = spansion_read_cr_quad_enable;
2760                 break;
2761
2762         default:
2763                 return -EINVAL;
2764         }
2765
2766         return 0;
2767 }
2768
2769 #define SMPT_CMD_ADDRESS_LEN_MASK               GENMASK(23, 22)
2770 #define SMPT_CMD_ADDRESS_LEN_0                  (0x0UL << 22)
2771 #define SMPT_CMD_ADDRESS_LEN_3                  (0x1UL << 22)
2772 #define SMPT_CMD_ADDRESS_LEN_4                  (0x2UL << 22)
2773 #define SMPT_CMD_ADDRESS_LEN_USE_CURRENT        (0x3UL << 22)
2774
2775 #define SMPT_CMD_READ_DUMMY_MASK                GENMASK(19, 16)
2776 #define SMPT_CMD_READ_DUMMY_SHIFT               16
2777 #define SMPT_CMD_READ_DUMMY(_cmd) \
2778         (((_cmd) & SMPT_CMD_READ_DUMMY_MASK) >> SMPT_CMD_READ_DUMMY_SHIFT)
2779 #define SMPT_CMD_READ_DUMMY_IS_VARIABLE         0xfUL
2780
2781 #define SMPT_CMD_READ_DATA_MASK                 GENMASK(31, 24)
2782 #define SMPT_CMD_READ_DATA_SHIFT                24
2783 #define SMPT_CMD_READ_DATA(_cmd) \
2784         (((_cmd) & SMPT_CMD_READ_DATA_MASK) >> SMPT_CMD_READ_DATA_SHIFT)
2785
2786 #define SMPT_CMD_OPCODE_MASK                    GENMASK(15, 8)
2787 #define SMPT_CMD_OPCODE_SHIFT                   8
2788 #define SMPT_CMD_OPCODE(_cmd) \
2789         (((_cmd) & SMPT_CMD_OPCODE_MASK) >> SMPT_CMD_OPCODE_SHIFT)
2790
2791 #define SMPT_MAP_REGION_COUNT_MASK              GENMASK(23, 16)
2792 #define SMPT_MAP_REGION_COUNT_SHIFT             16
2793 #define SMPT_MAP_REGION_COUNT(_header) \
2794         ((((_header) & SMPT_MAP_REGION_COUNT_MASK) >> \
2795           SMPT_MAP_REGION_COUNT_SHIFT) + 1)
2796
2797 #define SMPT_MAP_ID_MASK                        GENMASK(15, 8)
2798 #define SMPT_MAP_ID_SHIFT                       8
2799 #define SMPT_MAP_ID(_header) \
2800         (((_header) & SMPT_MAP_ID_MASK) >> SMPT_MAP_ID_SHIFT)
2801
2802 #define SMPT_MAP_REGION_SIZE_MASK               GENMASK(31, 8)
2803 #define SMPT_MAP_REGION_SIZE_SHIFT              8
2804 #define SMPT_MAP_REGION_SIZE(_region) \
2805         (((((_region) & SMPT_MAP_REGION_SIZE_MASK) >> \
2806            SMPT_MAP_REGION_SIZE_SHIFT) + 1) * 256)
2807
2808 #define SMPT_MAP_REGION_ERASE_TYPE_MASK         GENMASK(3, 0)
2809 #define SMPT_MAP_REGION_ERASE_TYPE(_region) \
2810         ((_region) & SMPT_MAP_REGION_ERASE_TYPE_MASK)
2811
2812 #define SMPT_DESC_TYPE_MAP                      BIT(1)
2813 #define SMPT_DESC_END                           BIT(0)
2814
2815 /**
2816  * spi_nor_smpt_addr_width() - return the address width used in the
2817  *                             configuration detection command.
2818  * @nor:        pointer to a 'struct spi_nor'
2819  * @settings:   configuration detection command descriptor, dword1
2820  */
2821 static u8 spi_nor_smpt_addr_width(const struct spi_nor *nor, const u32 settings)
2822 {
2823         switch (settings & SMPT_CMD_ADDRESS_LEN_MASK) {
2824         case SMPT_CMD_ADDRESS_LEN_0:
2825                 return 0;
2826         case SMPT_CMD_ADDRESS_LEN_3:
2827                 return 3;
2828         case SMPT_CMD_ADDRESS_LEN_4:
2829                 return 4;
2830         case SMPT_CMD_ADDRESS_LEN_USE_CURRENT:
2831                 /* fall through */
2832         default:
2833                 return nor->addr_width;
2834         }
2835 }
2836
2837 /**
2838  * spi_nor_smpt_read_dummy() - return the configuration detection command read
2839  *                             latency, in clock cycles.
2840  * @nor:        pointer to a 'struct spi_nor'
2841  * @settings:   configuration detection command descriptor, dword1
2842  *
2843  * Return: the number of dummy cycles for an SMPT read
2844  */
2845 static u8 spi_nor_smpt_read_dummy(const struct spi_nor *nor, const u32 settings)
2846 {
2847         u8 read_dummy = SMPT_CMD_READ_DUMMY(settings);
2848
2849         if (read_dummy == SMPT_CMD_READ_DUMMY_IS_VARIABLE)
2850                 return nor->read_dummy;
2851         return read_dummy;
2852 }
2853
2854 /**
2855  * spi_nor_get_map_in_use() - get the configuration map in use
2856  * @nor:        pointer to a 'struct spi_nor'
2857  * @smpt:       pointer to the sector map parameter table
2858  */
2859 static const u32 *spi_nor_get_map_in_use(struct spi_nor *nor, const u32 *smpt)
2860 {
2861         const u32 *ret = NULL;
2862         u32 i, addr;
2863         int err;
2864         u8 addr_width, read_opcode, read_dummy;
2865         u8 read_data_mask, data_byte, map_id;
2866
2867         addr_width = nor->addr_width;
2868         read_dummy = nor->read_dummy;
2869         read_opcode = nor->read_opcode;
2870
2871         map_id = 0;
2872         i = 0;
2873         /* Determine if there are any optional Detection Command Descriptors */
2874         while (!(smpt[i] & SMPT_DESC_TYPE_MAP)) {
2875                 read_data_mask = SMPT_CMD_READ_DATA(smpt[i]);
2876                 nor->addr_width = spi_nor_smpt_addr_width(nor, smpt[i]);
2877                 nor->read_dummy = spi_nor_smpt_read_dummy(nor, smpt[i]);
2878                 nor->read_opcode = SMPT_CMD_OPCODE(smpt[i]);
2879                 addr = smpt[i + 1];
2880
2881                 err = spi_nor_read_raw(nor, addr, 1, &data_byte);
2882                 if (err)
2883                         goto out;
2884
2885                 /*
2886                  * Build an index value that is used to select the Sector Map
2887                  * Configuration that is currently in use.
2888                  */
2889                 map_id = map_id << 1 | !!(data_byte & read_data_mask);
2890                 i = i + 2;
2891         }
2892
2893         /* Find the matching configuration map */
2894         while (SMPT_MAP_ID(smpt[i]) != map_id) {
2895                 if (smpt[i] & SMPT_DESC_END)
2896                         goto out;
2897                 /* increment the table index to the next map */
2898                 i += SMPT_MAP_REGION_COUNT(smpt[i]) + 1;
2899         }
2900
2901         ret = smpt + i;
2902         /* fall through */
2903 out:
2904         nor->addr_width = addr_width;
2905         nor->read_dummy = read_dummy;
2906         nor->read_opcode = read_opcode;
2907         return ret;
2908 }
2909
2910 /**
2911  * spi_nor_region_check_overlay() - set overlay bit when the region is overlaid
2912  * @region:     pointer to a structure that describes a SPI NOR erase region
2913  * @erase:      pointer to a structure that describes a SPI NOR erase type
2914  * @erase_type: erase type bitmask
2915  */
2916 static void
2917 spi_nor_region_check_overlay(struct spi_nor_erase_region *region,
2918                              const struct spi_nor_erase_type *erase,
2919                              const u8 erase_type)
2920 {
2921         int i;
2922
2923         for (i = 0; i < SNOR_ERASE_TYPE_MAX; i++) {
2924                 if (!(erase_type & BIT(i)))
2925                         continue;
2926                 if (region->size & erase[i].size_mask) {
2927                         spi_nor_region_mark_overlay(region);
2928                         return;
2929                 }
2930         }
2931 }
2932
2933 /**
2934  * spi_nor_init_non_uniform_erase_map() - initialize the non-uniform erase map
2935  * @nor:        pointer to a 'struct spi_nor'
2936  * @smpt:       pointer to the sector map parameter table
2937  *
2938  * Return: 0 on success, -errno otherwise.
2939  */
2940 static int spi_nor_init_non_uniform_erase_map(struct spi_nor *nor,
2941                                               const u32 *smpt)
2942 {
2943         struct spi_nor_erase_map *map = &nor->erase_map;
2944         const struct spi_nor_erase_type *erase = map->erase_type;
2945         struct spi_nor_erase_region *region;
2946         u64 offset;
2947         u32 region_count;
2948         int i, j;
2949         u8 erase_type;
2950
2951         region_count = SMPT_MAP_REGION_COUNT(*smpt);
2952         /*
2953          * The regions will be freed when the driver detaches from the
2954          * device.
2955          */
2956         region = devm_kcalloc(nor->dev, region_count, sizeof(*region),
2957                               GFP_KERNEL);
2958         if (!region)
2959                 return -ENOMEM;
2960         map->regions = region;
2961
2962         map->uniform_erase_type = 0xff;
2963         offset = 0;
2964         /* Populate regions. */
2965         for (i = 0; i < region_count; i++) {
2966                 j = i + 1; /* index for the region dword */
2967                 region[i].size = SMPT_MAP_REGION_SIZE(smpt[j]);
2968                 erase_type = SMPT_MAP_REGION_ERASE_TYPE(smpt[j]);
2969                 region[i].offset = offset | erase_type;
2970
2971                 spi_nor_region_check_overlay(&region[i], erase, erase_type);
2972
2973                 /*
2974                  * Save the erase types that are supported in all regions and
2975                  * can erase the entire flash memory.
2976                  */
2977                 map->uniform_erase_type &= erase_type;
2978
2979                 offset = (region[i].offset & ~SNOR_ERASE_FLAGS_MASK) +
2980                          region[i].size;
2981         }
2982
2983         spi_nor_region_mark_end(&region[i - 1]);
2984
2985         return 0;
2986 }
2987
2988 /**
2989  * spi_nor_parse_smpt() - parse Sector Map Parameter Table
2990  * @nor:                pointer to a 'struct spi_nor'
2991  * @smpt_header:        sector map parameter table header
2992  *
2993  * This table is optional, but when available, we parse it to identify the
2994  * location and size of sectors within the main data array of the flash memory
2995  * device and to identify which Erase Types are supported by each sector.
2996  *
2997  * Return: 0 on success, -errno otherwise.
2998  */
2999 static int spi_nor_parse_smpt(struct spi_nor *nor,
3000                               const struct sfdp_parameter_header *smpt_header)
3001 {
3002         const u32 *sector_map;
3003         u32 *smpt;
3004         size_t len;
3005         u32 addr;
3006         int i, ret;
3007
3008         /* Read the Sector Map Parameter Table. */
3009         len = smpt_header->length * sizeof(*smpt);
3010         smpt = kzalloc(len, GFP_KERNEL);
3011         if (!smpt)
3012                 return -ENOMEM;
3013
3014         addr = SFDP_PARAM_HEADER_PTP(smpt_header);
3015         ret = spi_nor_read_sfdp(nor, addr, len, smpt);
3016         if (ret)
3017                 goto out;
3018
3019         /* Fix endianness of the SMPT DWORDs. */
3020         for (i = 0; i < smpt_header->length; i++)
3021                 smpt[i] = le32_to_cpu(smpt[i]);
3022
3023         sector_map = spi_nor_get_map_in_use(nor, smpt);
3024         if (!sector_map) {
3025                 ret = -EINVAL;
3026                 goto out;
3027         }
3028
3029         ret = spi_nor_init_non_uniform_erase_map(nor, sector_map);
3030         if (ret)
3031                 goto out;
3032
3033         spi_nor_regions_sort_erase_types(&nor->erase_map);
3034         /* fall through */
3035 out:
3036         kfree(smpt);
3037         return ret;
3038 }
3039
3040 /**
3041  * spi_nor_parse_sfdp() - parse the Serial Flash Discoverable Parameters.
3042  * @nor:                pointer to a 'struct spi_nor'
3043  * @params:             pointer to the 'struct spi_nor_flash_parameter' to be
3044  *                      filled
3045  *
3046  * The Serial Flash Discoverable Parameters are described by the JEDEC JESD216
3047  * specification. This is a standard which tends to supported by almost all
3048  * (Q)SPI memory manufacturers. Those hard-coded tables allow us to learn at
3049  * runtime the main parameters needed to perform basic SPI flash operations such
3050  * as Fast Read, Page Program or Sector Erase commands.
3051  *
3052  * Return: 0 on success, -errno otherwise.
3053  */
3054 static int spi_nor_parse_sfdp(struct spi_nor *nor,
3055                               struct spi_nor_flash_parameter *params)
3056 {
3057         const struct sfdp_parameter_header *param_header, *bfpt_header;
3058         struct sfdp_parameter_header *param_headers = NULL;
3059         struct sfdp_header header;
3060         struct device *dev = nor->dev;
3061         size_t psize;
3062         int i, err;
3063
3064         /* Get the SFDP header. */
3065         err = spi_nor_read_sfdp_dma_unsafe(nor, 0, sizeof(header), &header);
3066         if (err < 0)
3067                 return err;
3068
3069         /* Check the SFDP header version. */
3070         if (le32_to_cpu(header.signature) != SFDP_SIGNATURE ||
3071             header.major != SFDP_JESD216_MAJOR)
3072                 return -EINVAL;
3073
3074         /*
3075          * Verify that the first and only mandatory parameter header is a
3076          * Basic Flash Parameter Table header as specified in JESD216.
3077          */
3078         bfpt_header = &header.bfpt_header;
3079         if (SFDP_PARAM_HEADER_ID(bfpt_header) != SFDP_BFPT_ID ||
3080             bfpt_header->major != SFDP_JESD216_MAJOR)
3081                 return -EINVAL;
3082
3083         /*
3084          * Allocate memory then read all parameter headers with a single
3085          * Read SFDP command. These parameter headers will actually be parsed
3086          * twice: a first time to get the latest revision of the basic flash
3087          * parameter table, then a second time to handle the supported optional
3088          * tables.
3089          * Hence we read the parameter headers once for all to reduce the
3090          * processing time. Also we use kmalloc() instead of devm_kmalloc()
3091          * because we don't need to keep these parameter headers: the allocated
3092          * memory is always released with kfree() before exiting this function.
3093          */
3094         if (header.nph) {
3095                 psize = header.nph * sizeof(*param_headers);
3096
3097                 param_headers = kmalloc(psize, GFP_KERNEL);
3098                 if (!param_headers)
3099                         return -ENOMEM;
3100
3101                 err = spi_nor_read_sfdp(nor, sizeof(header),
3102                                         psize, param_headers);
3103                 if (err < 0) {
3104                         dev_err(dev, "failed to read SFDP parameter headers\n");
3105                         goto exit;
3106                 }
3107         }
3108
3109         /*
3110          * Check other parameter headers to get the latest revision of
3111          * the basic flash parameter table.
3112          */
3113         for (i = 0; i < header.nph; i++) {
3114                 param_header = &param_headers[i];
3115
3116                 if (SFDP_PARAM_HEADER_ID(param_header) == SFDP_BFPT_ID &&
3117                     param_header->major == SFDP_JESD216_MAJOR &&
3118                     (param_header->minor > bfpt_header->minor ||
3119                      (param_header->minor == bfpt_header->minor &&
3120                       param_header->length > bfpt_header->length)))
3121                         bfpt_header = param_header;
3122         }
3123
3124         err = spi_nor_parse_bfpt(nor, bfpt_header, params);
3125         if (err)
3126                 goto exit;
3127
3128         /* Parse other parameter headers. */
3129         for (i = 0; i < header.nph; i++) {
3130                 param_header = &param_headers[i];
3131
3132                 switch (SFDP_PARAM_HEADER_ID(param_header)) {
3133                 case SFDP_SECTOR_MAP_ID:
3134                         err = spi_nor_parse_smpt(nor, param_header);
3135                         break;
3136
3137                 default:
3138                         break;
3139                 }
3140
3141                 if (err)
3142                         goto exit;
3143         }
3144
3145 exit:
3146         kfree(param_headers);
3147         return err;
3148 }
3149
3150 static int spi_nor_init_params(struct spi_nor *nor,
3151                                const struct flash_info *info,
3152                                struct spi_nor_flash_parameter *params)
3153 {
3154         struct spi_nor_erase_map *map = &nor->erase_map;
3155         u8 i, erase_mask;
3156
3157         /* Set legacy flash parameters as default. */
3158         memset(params, 0, sizeof(*params));
3159
3160         /* Set SPI NOR sizes. */
3161         params->size = info->sector_size * info->n_sectors;
3162         params->page_size = info->page_size;
3163
3164         /* (Fast) Read settings. */
3165         params->hwcaps.mask |= SNOR_HWCAPS_READ;
3166         spi_nor_set_read_settings(&params->reads[SNOR_CMD_READ],
3167                                   0, 0, SPINOR_OP_READ,
3168                                   SNOR_PROTO_1_1_1);
3169
3170         if (!(info->flags & SPI_NOR_NO_FR)) {
3171                 params->hwcaps.mask |= SNOR_HWCAPS_READ_FAST;
3172                 spi_nor_set_read_settings(&params->reads[SNOR_CMD_READ_FAST],
3173                                           0, 8, SPINOR_OP_READ_FAST,
3174                                           SNOR_PROTO_1_1_1);
3175         }
3176
3177         if (info->flags & SPI_NOR_DUAL_READ) {
3178                 params->hwcaps.mask |= SNOR_HWCAPS_READ_1_1_2;
3179                 spi_nor_set_read_settings(&params->reads[SNOR_CMD_READ_1_1_2],
3180                                           0, 8, SPINOR_OP_READ_1_1_2,
3181                                           SNOR_PROTO_1_1_2);
3182         }
3183
3184         if (info->flags & SPI_NOR_QUAD_READ) {
3185                 params->hwcaps.mask |= SNOR_HWCAPS_READ_1_1_4;
3186                 spi_nor_set_read_settings(&params->reads[SNOR_CMD_READ_1_1_4],
3187                                           0, 8, SPINOR_OP_READ_1_1_4,
3188                                           SNOR_PROTO_1_1_4);
3189         }
3190
3191         /* Page Program settings. */
3192         params->hwcaps.mask |= SNOR_HWCAPS_PP;
3193         spi_nor_set_pp_settings(&params->page_programs[SNOR_CMD_PP],
3194                                 SPINOR_OP_PP, SNOR_PROTO_1_1_1);
3195
3196         /*
3197          * Sector Erase settings. Sort Erase Types in ascending order, with the
3198          * smallest erase size starting at BIT(0).
3199          */
3200         erase_mask = 0;
3201         i = 0;
3202         if (info->flags & SECT_4K_PMC) {
3203                 erase_mask |= BIT(i);
3204                 spi_nor_set_erase_type(&map->erase_type[i], 4096u,
3205                                        SPINOR_OP_BE_4K_PMC);
3206                 i++;
3207         } else if (info->flags & SECT_4K) {
3208                 erase_mask |= BIT(i);
3209                 spi_nor_set_erase_type(&map->erase_type[i], 4096u,
3210                                        SPINOR_OP_BE_4K);
3211                 i++;
3212         }
3213         erase_mask |= BIT(i);
3214         spi_nor_set_erase_type(&map->erase_type[i], info->sector_size,
3215                                SPINOR_OP_SE);
3216         spi_nor_init_uniform_erase_map(map, erase_mask, params->size);
3217
3218         /* Select the procedure to set the Quad Enable bit. */
3219         if (params->hwcaps.mask & (SNOR_HWCAPS_READ_QUAD |
3220                                    SNOR_HWCAPS_PP_QUAD)) {
3221                 switch (JEDEC_MFR(info)) {
3222                 case SNOR_MFR_MACRONIX:
3223                         params->quad_enable = macronix_quad_enable;
3224                         break;
3225
3226                 case SNOR_MFR_MICRON:
3227                         break;
3228
3229                 default:
3230                         /* Kept only for backward compatibility purpose. */
3231                         params->quad_enable = spansion_quad_enable;
3232                         break;
3233                 }
3234
3235                 /*
3236                  * Some manufacturer like GigaDevice may use different
3237                  * bit to set QE on different memories, so the MFR can't
3238                  * indicate the quad_enable method for this case, we need
3239                  * set it in flash info list.
3240                  */
3241                 if (info->quad_enable)
3242                         params->quad_enable = info->quad_enable;
3243         }
3244
3245         if ((info->flags & (SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ)) &&
3246             !(info->flags & SPI_NOR_SKIP_SFDP)) {
3247                 struct spi_nor_flash_parameter sfdp_params;
3248                 struct spi_nor_erase_map prev_map;
3249
3250                 memcpy(&sfdp_params, params, sizeof(sfdp_params));
3251                 memcpy(&prev_map, &nor->erase_map, sizeof(prev_map));
3252
3253                 if (spi_nor_parse_sfdp(nor, &sfdp_params))
3254                         /* restore previous erase map */
3255                         memcpy(&nor->erase_map, &prev_map,
3256                                sizeof(nor->erase_map));
3257                 else
3258                         memcpy(params, &sfdp_params, sizeof(*params));
3259         }
3260
3261         return 0;
3262 }
3263
3264 static int spi_nor_hwcaps2cmd(u32 hwcaps, const int table[][2], size_t size)
3265 {
3266         size_t i;
3267
3268         for (i = 0; i < size; i++)
3269                 if (table[i][0] == (int)hwcaps)
3270                         return table[i][1];
3271
3272         return -EINVAL;
3273 }
3274
3275 static int spi_nor_hwcaps_read2cmd(u32 hwcaps)
3276 {
3277         static const int hwcaps_read2cmd[][2] = {
3278                 { SNOR_HWCAPS_READ,             SNOR_CMD_READ },
3279                 { SNOR_HWCAPS_READ_FAST,        SNOR_CMD_READ_FAST },
3280                 { SNOR_HWCAPS_READ_1_1_1_DTR,   SNOR_CMD_READ_1_1_1_DTR },
3281                 { SNOR_HWCAPS_READ_1_1_2,       SNOR_CMD_READ_1_1_2 },
3282                 { SNOR_HWCAPS_READ_1_2_2,       SNOR_CMD_READ_1_2_2 },
3283                 { SNOR_HWCAPS_READ_2_2_2,       SNOR_CMD_READ_2_2_2 },
3284                 { SNOR_HWCAPS_READ_1_2_2_DTR,   SNOR_CMD_READ_1_2_2_DTR },
3285                 { SNOR_HWCAPS_READ_1_1_4,       SNOR_CMD_READ_1_1_4 },
3286                 { SNOR_HWCAPS_READ_1_4_4,       SNOR_CMD_READ_1_4_4 },
3287                 { SNOR_HWCAPS_READ_4_4_4,       SNOR_CMD_READ_4_4_4 },
3288                 { SNOR_HWCAPS_READ_1_4_4_DTR,   SNOR_CMD_READ_1_4_4_DTR },
3289                 { SNOR_HWCAPS_READ_1_1_8,       SNOR_CMD_READ_1_1_8 },
3290                 { SNOR_HWCAPS_READ_1_8_8,       SNOR_CMD_READ_1_8_8 },
3291                 { SNOR_HWCAPS_READ_8_8_8,       SNOR_CMD_READ_8_8_8 },
3292                 { SNOR_HWCAPS_READ_1_8_8_DTR,   SNOR_CMD_READ_1_8_8_DTR },
3293         };
3294
3295         return spi_nor_hwcaps2cmd(hwcaps, hwcaps_read2cmd,
3296                                   ARRAY_SIZE(hwcaps_read2cmd));
3297 }
3298
3299 static int spi_nor_hwcaps_pp2cmd(u32 hwcaps)
3300 {
3301         static const int hwcaps_pp2cmd[][2] = {
3302                 { SNOR_HWCAPS_PP,               SNOR_CMD_PP },
3303                 { SNOR_HWCAPS_PP_1_1_4,         SNOR_CMD_PP_1_1_4 },
3304                 { SNOR_HWCAPS_PP_1_4_4,         SNOR_CMD_PP_1_4_4 },
3305                 { SNOR_HWCAPS_PP_4_4_4,         SNOR_CMD_PP_4_4_4 },
3306                 { SNOR_HWCAPS_PP_1_1_8,         SNOR_CMD_PP_1_1_8 },
3307                 { SNOR_HWCAPS_PP_1_8_8,         SNOR_CMD_PP_1_8_8 },
3308                 { SNOR_HWCAPS_PP_8_8_8,         SNOR_CMD_PP_8_8_8 },
3309         };
3310
3311         return spi_nor_hwcaps2cmd(hwcaps, hwcaps_pp2cmd,
3312                                   ARRAY_SIZE(hwcaps_pp2cmd));
3313 }
3314
3315 static int spi_nor_select_read(struct spi_nor *nor,
3316                                const struct spi_nor_flash_parameter *params,
3317                                u32 shared_hwcaps)
3318 {
3319         int cmd, best_match = fls(shared_hwcaps & SNOR_HWCAPS_READ_MASK) - 1;
3320         const struct spi_nor_read_command *read;
3321
3322         if (best_match < 0)
3323                 return -EINVAL;
3324
3325         cmd = spi_nor_hwcaps_read2cmd(BIT(best_match));
3326         if (cmd < 0)
3327                 return -EINVAL;
3328
3329         read = &params->reads[cmd];
3330         nor->read_opcode = read->opcode;
3331         nor->read_proto = read->proto;
3332
3333         /*
3334          * In the spi-nor framework, we don't need to make the difference
3335          * between mode clock cycles and wait state clock cycles.
3336          * Indeed, the value of the mode clock cycles is used by a QSPI
3337          * flash memory to know whether it should enter or leave its 0-4-4
3338          * (Continuous Read / XIP) mode.
3339          * eXecution In Place is out of the scope of the mtd sub-system.
3340          * Hence we choose to merge both mode and wait state clock cycles
3341          * into the so called dummy clock cycles.
3342          */
3343         nor->read_dummy = read->num_mode_clocks + read->num_wait_states;
3344         return 0;
3345 }
3346
3347 static int spi_nor_select_pp(struct spi_nor *nor,
3348                              const struct spi_nor_flash_parameter *params,
3349                              u32 shared_hwcaps)
3350 {
3351         int cmd, best_match = fls(shared_hwcaps & SNOR_HWCAPS_PP_MASK) - 1;
3352         const struct spi_nor_pp_command *pp;
3353
3354         if (best_match < 0)
3355                 return -EINVAL;
3356
3357         cmd = spi_nor_hwcaps_pp2cmd(BIT(best_match));
3358         if (cmd < 0)
3359                 return -EINVAL;
3360
3361         pp = &params->page_programs[cmd];
3362         nor->program_opcode = pp->opcode;
3363         nor->write_proto = pp->proto;
3364         return 0;
3365 }
3366
3367 /**
3368  * spi_nor_select_uniform_erase() - select optimum uniform erase type
3369  * @map:                the erase map of the SPI NOR
3370  * @wanted_size:        the erase type size to search for. Contains the value of
3371  *                      info->sector_size or of the "small sector" size in case
3372  *                      CONFIG_MTD_SPI_NOR_USE_4K_SECTORS is defined.
3373  *
3374  * Once the optimum uniform sector erase command is found, disable all the
3375  * other.
3376  *
3377  * Return: pointer to erase type on success, NULL otherwise.
3378  */
3379 static const struct spi_nor_erase_type *
3380 spi_nor_select_uniform_erase(struct spi_nor_erase_map *map,
3381                              const u32 wanted_size)
3382 {
3383         const struct spi_nor_erase_type *tested_erase, *erase = NULL;
3384         int i;
3385         u8 uniform_erase_type = map->uniform_erase_type;
3386
3387         for (i = SNOR_ERASE_TYPE_MAX - 1; i >= 0; i--) {
3388                 if (!(uniform_erase_type & BIT(i)))
3389                         continue;
3390
3391                 tested_erase = &map->erase_type[i];
3392
3393                 /*
3394                  * If the current erase size is the one, stop here:
3395                  * we have found the right uniform Sector Erase command.
3396                  */
3397                 if (tested_erase->size == wanted_size) {
3398                         erase = tested_erase;
3399                         break;
3400                 }
3401
3402                 /*
3403                  * Otherwise, the current erase size is still a valid canditate.
3404                  * Select the biggest valid candidate.
3405                  */
3406                 if (!erase && tested_erase->size)
3407                         erase = tested_erase;
3408                         /* keep iterating to find the wanted_size */
3409         }
3410
3411         if (!erase)
3412                 return NULL;
3413
3414         /* Disable all other Sector Erase commands. */
3415         map->uniform_erase_type &= ~SNOR_ERASE_TYPE_MASK;
3416         map->uniform_erase_type |= BIT(erase - map->erase_type);
3417         return erase;
3418 }
3419
3420 static int spi_nor_select_erase(struct spi_nor *nor, u32 wanted_size)
3421 {
3422         struct spi_nor_erase_map *map = &nor->erase_map;
3423         const struct spi_nor_erase_type *erase = NULL;
3424         struct mtd_info *mtd = &nor->mtd;
3425         int i;
3426
3427         /*
3428          * The previous implementation handling Sector Erase commands assumed
3429          * that the SPI flash memory has an uniform layout then used only one
3430          * of the supported erase sizes for all Sector Erase commands.
3431          * So to be backward compatible, the new implementation also tries to
3432          * manage the SPI flash memory as uniform with a single erase sector
3433          * size, when possible.
3434          */
3435 #ifdef CONFIG_MTD_SPI_NOR_USE_4K_SECTORS
3436         /* prefer "small sector" erase if possible */
3437         wanted_size = 4096u;
3438 #endif
3439
3440         if (spi_nor_has_uniform_erase(nor)) {
3441                 erase = spi_nor_select_uniform_erase(map, wanted_size);
3442                 if (!erase)
3443                         return -EINVAL;
3444                 nor->erase_opcode = erase->opcode;
3445                 mtd->erasesize = erase->size;
3446                 return 0;
3447         }
3448
3449         /*
3450          * For non-uniform SPI flash memory, set mtd->erasesize to the
3451          * maximum erase sector size. No need to set nor->erase_opcode.
3452          */
3453         for (i = SNOR_ERASE_TYPE_MAX - 1; i >= 0; i--) {
3454                 if (map->erase_type[i].size) {
3455                         erase = &map->erase_type[i];
3456                         break;
3457                 }
3458         }
3459
3460         if (!erase)
3461                 return -EINVAL;
3462
3463         mtd->erasesize = erase->size;
3464         return 0;
3465 }
3466
3467 static int spi_nor_setup(struct spi_nor *nor, const struct flash_info *info,
3468                          const struct spi_nor_flash_parameter *params,
3469                          const struct spi_nor_hwcaps *hwcaps)
3470 {
3471         u32 ignored_mask, shared_mask;
3472         bool enable_quad_io;
3473         int err;
3474
3475         /*
3476          * Keep only the hardware capabilities supported by both the SPI
3477          * controller and the SPI flash memory.
3478          */
3479         shared_mask = hwcaps->mask & params->hwcaps.mask;
3480
3481         /* SPI n-n-n protocols are not supported yet. */
3482         ignored_mask = (SNOR_HWCAPS_READ_2_2_2 |
3483                         SNOR_HWCAPS_READ_4_4_4 |
3484                         SNOR_HWCAPS_READ_8_8_8 |
3485                         SNOR_HWCAPS_PP_4_4_4 |
3486                         SNOR_HWCAPS_PP_8_8_8);
3487         if (shared_mask & ignored_mask) {
3488                 dev_dbg(nor->dev,
3489                         "SPI n-n-n protocols are not supported yet.\n");
3490                 shared_mask &= ~ignored_mask;
3491         }
3492
3493         /* Select the (Fast) Read command. */
3494         err = spi_nor_select_read(nor, params, shared_mask);
3495         if (err) {
3496                 dev_err(nor->dev,
3497                         "can't select read settings supported by both the SPI controller and memory.\n");
3498                 return err;
3499         }
3500
3501         /* Select the Page Program command. */
3502         err = spi_nor_select_pp(nor, params, shared_mask);
3503         if (err) {
3504                 dev_err(nor->dev,
3505                         "can't select write settings supported by both the SPI controller and memory.\n");
3506                 return err;
3507         }
3508
3509         /* Select the Sector Erase command. */
3510         err = spi_nor_select_erase(nor, info->sector_size);
3511         if (err) {
3512                 dev_err(nor->dev,
3513                         "can't select erase settings supported by both the SPI controller and memory.\n");
3514                 return err;
3515         }
3516
3517         /* Enable Quad I/O if needed. */
3518         enable_quad_io = (spi_nor_get_protocol_width(nor->read_proto) == 4 ||
3519                           spi_nor_get_protocol_width(nor->write_proto) == 4);
3520         if (enable_quad_io && params->quad_enable)
3521                 nor->quad_enable = params->quad_enable;
3522         else
3523                 nor->quad_enable = NULL;
3524
3525         return 0;
3526 }
3527
3528 static int spi_nor_init(struct spi_nor *nor)
3529 {
3530         int err;
3531
3532         /*
3533          * Atmel, SST, Intel/Numonyx, and others serial NOR tend to power up
3534          * with the software protection bits set
3535          */
3536         if (JEDEC_MFR(nor->info) == SNOR_MFR_ATMEL ||
3537             JEDEC_MFR(nor->info) == SNOR_MFR_INTEL ||
3538             JEDEC_MFR(nor->info) == SNOR_MFR_SST ||
3539             nor->info->flags & SPI_NOR_HAS_LOCK) {
3540                 write_enable(nor);
3541                 write_sr(nor, 0);
3542                 spi_nor_wait_till_ready(nor);
3543         }
3544
3545         if (nor->quad_enable) {
3546                 err = nor->quad_enable(nor);
3547                 if (err) {
3548                         dev_err(nor->dev, "quad mode not supported\n");
3549                         return err;
3550                 }
3551         }
3552
3553         if ((nor->addr_width == 4) &&
3554             (JEDEC_MFR(nor->info) != SNOR_MFR_SPANSION) &&
3555             !(nor->info->flags & SPI_NOR_4B_OPCODES)) {
3556                 /*
3557                  * If the RESET# pin isn't hooked up properly, or the system
3558                  * otherwise doesn't perform a reset command in the boot
3559                  * sequence, it's impossible to 100% protect against unexpected
3560                  * reboots (e.g., crashes). Warn the user (or hopefully, system
3561                  * designer) that this is bad.
3562                  */
3563                 WARN_ONCE(nor->flags & SNOR_F_BROKEN_RESET,
3564                           "enabling reset hack; may not recover from unexpected reboots\n");
3565                 set_4byte(nor, nor->info, 1);
3566         }
3567
3568         return 0;
3569 }
3570
3571 /* mtd resume handler */
3572 static void spi_nor_resume(struct mtd_info *mtd)
3573 {
3574         struct spi_nor *nor = mtd_to_spi_nor(mtd);
3575         struct device *dev = nor->dev;
3576         int ret;
3577
3578         /* re-initialize the nor chip */
3579         ret = spi_nor_init(nor);
3580         if (ret)
3581                 dev_err(dev, "resume() failed\n");
3582 }
3583
3584 void spi_nor_restore(struct spi_nor *nor)
3585 {
3586         /* restore the addressing mode */
3587         if ((nor->addr_width == 4) &&
3588             (JEDEC_MFR(nor->info) != SNOR_MFR_SPANSION) &&
3589             !(nor->info->flags & SPI_NOR_4B_OPCODES) &&
3590             (nor->flags & SNOR_F_BROKEN_RESET))
3591                 set_4byte(nor, nor->info, 0);
3592 }
3593 EXPORT_SYMBOL_GPL(spi_nor_restore);
3594
3595 int spi_nor_scan(struct spi_nor *nor, const char *name,
3596                  const struct spi_nor_hwcaps *hwcaps)
3597 {
3598         struct spi_nor_flash_parameter params;
3599         const struct flash_info *info = NULL;
3600         struct device *dev = nor->dev;
3601         struct mtd_info *mtd = &nor->mtd;
3602         struct device_node *np = spi_nor_get_flash_node(nor);
3603         int ret;
3604         int i;
3605
3606         ret = spi_nor_check(nor);
3607         if (ret)
3608                 return ret;
3609
3610         /* Reset SPI protocol for all commands. */
3611         nor->reg_proto = SNOR_PROTO_1_1_1;
3612         nor->read_proto = SNOR_PROTO_1_1_1;
3613         nor->write_proto = SNOR_PROTO_1_1_1;
3614
3615         if (name)
3616                 info = spi_nor_match_id(name);
3617         /* Try to auto-detect if chip name wasn't specified or not found */
3618         if (!info)
3619                 info = spi_nor_read_id(nor);
3620         if (IS_ERR_OR_NULL(info))
3621                 return -ENOENT;
3622
3623         /*
3624          * If caller has specified name of flash model that can normally be
3625          * detected using JEDEC, let's verify it.
3626          */
3627         if (name && info->id_len) {
3628                 const struct flash_info *jinfo;
3629
3630                 jinfo = spi_nor_read_id(nor);
3631                 if (IS_ERR(jinfo)) {
3632                         return PTR_ERR(jinfo);
3633                 } else if (jinfo != info) {
3634                         /*
3635                          * JEDEC knows better, so overwrite platform ID. We
3636                          * can't trust partitions any longer, but we'll let
3637                          * mtd apply them anyway, since some partitions may be
3638                          * marked read-only, and we don't want to lose that
3639                          * information, even if it's not 100% accurate.
3640                          */
3641                         dev_warn(dev, "found %s, expected %s\n",
3642                                  jinfo->name, info->name);
3643                         info = jinfo;
3644                 }
3645         }
3646
3647         mutex_init(&nor->lock);
3648
3649         /*
3650          * Make sure the XSR_RDY flag is set before calling
3651          * spi_nor_wait_till_ready(). Xilinx S3AN share MFR
3652          * with Atmel spi-nor
3653          */
3654         if (info->flags & SPI_S3AN)
3655                 nor->flags |=  SNOR_F_READY_XSR_RDY;
3656
3657         /* Parse the Serial Flash Discoverable Parameters table. */
3658         ret = spi_nor_init_params(nor, info, &params);
3659         if (ret)
3660                 return ret;
3661
3662         if (!mtd->name)
3663                 mtd->name = dev_name(dev);
3664         mtd->priv = nor;
3665         mtd->type = MTD_NORFLASH;
3666         mtd->writesize = 1;
3667         mtd->flags = MTD_CAP_NORFLASH;
3668         mtd->size = params.size;
3669         mtd->_erase = spi_nor_erase;
3670         mtd->_read = spi_nor_read;
3671         mtd->_resume = spi_nor_resume;
3672
3673         /* NOR protection support for STmicro/Micron chips and similar */
3674         if (JEDEC_MFR(info) == SNOR_MFR_MICRON ||
3675                         info->flags & SPI_NOR_HAS_LOCK) {
3676                 nor->flash_lock = stm_lock;
3677                 nor->flash_unlock = stm_unlock;
3678                 nor->flash_is_locked = stm_is_locked;
3679         }
3680
3681         if (nor->flash_lock && nor->flash_unlock && nor->flash_is_locked) {
3682                 mtd->_lock = spi_nor_lock;
3683                 mtd->_unlock = spi_nor_unlock;
3684                 mtd->_is_locked = spi_nor_is_locked;
3685         }
3686
3687         /* sst nor chips use AAI word program */
3688         if (info->flags & SST_WRITE)
3689                 mtd->_write = sst_write;
3690         else
3691                 mtd->_write = spi_nor_write;
3692
3693         if (info->flags & USE_FSR)
3694                 nor->flags |= SNOR_F_USE_FSR;
3695         if (info->flags & SPI_NOR_HAS_TB)
3696                 nor->flags |= SNOR_F_HAS_SR_TB;
3697         if (info->flags & NO_CHIP_ERASE)
3698                 nor->flags |= SNOR_F_NO_OP_CHIP_ERASE;
3699         if (info->flags & USE_CLSR)
3700                 nor->flags |= SNOR_F_USE_CLSR;
3701
3702         if (info->flags & SPI_NOR_NO_ERASE)
3703                 mtd->flags |= MTD_NO_ERASE;
3704
3705         mtd->dev.parent = dev;
3706         nor->page_size = params.page_size;
3707         mtd->writebufsize = nor->page_size;
3708
3709         if (np) {
3710                 /* If we were instantiated by DT, use it */
3711                 if (of_property_read_bool(np, "m25p,fast-read"))
3712                         params.hwcaps.mask |= SNOR_HWCAPS_READ_FAST;
3713                 else
3714                         params.hwcaps.mask &= ~SNOR_HWCAPS_READ_FAST;
3715         } else {
3716                 /* If we weren't instantiated by DT, default to fast-read */
3717                 params.hwcaps.mask |= SNOR_HWCAPS_READ_FAST;
3718         }
3719
3720         if (of_property_read_bool(np, "broken-flash-reset"))
3721                 nor->flags |= SNOR_F_BROKEN_RESET;
3722
3723         /* Some devices cannot do fast-read, no matter what DT tells us */
3724         if (info->flags & SPI_NOR_NO_FR)
3725                 params.hwcaps.mask &= ~SNOR_HWCAPS_READ_FAST;
3726
3727         /*
3728          * Configure the SPI memory:
3729          * - select op codes for (Fast) Read, Page Program and Sector Erase.
3730          * - set the number of dummy cycles (mode cycles + wait states).
3731          * - set the SPI protocols for register and memory accesses.
3732          * - set the Quad Enable bit if needed (required by SPI x-y-4 protos).
3733          */
3734         ret = spi_nor_setup(nor, info, &params, hwcaps);
3735         if (ret)
3736                 return ret;
3737
3738         if (nor->addr_width) {
3739                 /* already configured from SFDP */
3740         } else if (info->addr_width) {
3741                 nor->addr_width = info->addr_width;
3742         } else if (mtd->size > 0x1000000) {
3743                 /* enable 4-byte addressing if the device exceeds 16MiB */
3744                 nor->addr_width = 4;
3745                 if (JEDEC_MFR(info) == SNOR_MFR_SPANSION ||
3746                     info->flags & SPI_NOR_4B_OPCODES)
3747                         spi_nor_set_4byte_opcodes(nor, info);
3748         } else {
3749                 nor->addr_width = 3;
3750         }
3751
3752         if (nor->addr_width > SPI_NOR_MAX_ADDR_WIDTH) {
3753                 dev_err(dev, "address width is too large: %u\n",
3754                         nor->addr_width);
3755                 return -EINVAL;
3756         }
3757
3758         if (info->flags & SPI_S3AN) {
3759                 ret = s3an_nor_scan(info, nor);
3760                 if (ret)
3761                         return ret;
3762         }
3763
3764         /* Send all the required SPI flash commands to initialize device */
3765         nor->info = info;
3766         ret = spi_nor_init(nor);
3767         if (ret)
3768                 return ret;
3769
3770         dev_info(dev, "%s (%lld Kbytes)\n", info->name,
3771                         (long long)mtd->size >> 10);
3772
3773         dev_dbg(dev,
3774                 "mtd .name = %s, .size = 0x%llx (%lldMiB), "
3775                 ".erasesize = 0x%.8x (%uKiB) .numeraseregions = %d\n",
3776                 mtd->name, (long long)mtd->size, (long long)(mtd->size >> 20),
3777                 mtd->erasesize, mtd->erasesize / 1024, mtd->numeraseregions);
3778
3779         if (mtd->numeraseregions)
3780                 for (i = 0; i < mtd->numeraseregions; i++)
3781                         dev_dbg(dev,
3782                                 "mtd.eraseregions[%d] = { .offset = 0x%llx, "
3783                                 ".erasesize = 0x%.8x (%uKiB), "
3784                                 ".numblocks = %d }\n",
3785                                 i, (long long)mtd->eraseregions[i].offset,
3786                                 mtd->eraseregions[i].erasesize,
3787                                 mtd->eraseregions[i].erasesize / 1024,
3788                                 mtd->eraseregions[i].numblocks);
3789         return 0;
3790 }
3791 EXPORT_SYMBOL_GPL(spi_nor_scan);
3792
3793 static const struct flash_info *spi_nor_match_id(const char *name)
3794 {
3795         const struct flash_info *id = spi_nor_ids;
3796
3797         while (id->name) {
3798                 if (!strcmp(name, id->name))
3799                         return id;
3800                 id++;
3801         }
3802         return NULL;
3803 }
3804
3805 MODULE_LICENSE("GPL");
3806 MODULE_AUTHOR("Huang Shijie <shijie8@gmail.com>");
3807 MODULE_AUTHOR("Mike Lavender");
3808 MODULE_DESCRIPTION("framework for SPI NOR");