drivers/mtd/spi-nor/spansion.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (C) 2005, Intec Automation Inc.
   4  * Copyright (C) 2014, Freescale Semiconductor, Inc.
   5  */
   6
   7 #include <linux/mtd/spi-nor.h>
   8
   9 #include "core.h"
  10
  11 /* flash_info mfr_flag. Used to clear sticky prorietary SR bits. */
  12 #define USE_CLSR        BIT(0)
  13
  14 #define SPINOR_OP_CLSR          0x30    /* Clear status register 1 */
  15 #define SPINOR_OP_RD_ANY_REG                    0x65    /* Read any register */
  16 #define SPINOR_OP_WR_ANY_REG                    0x71    /* Write any register */
  17 #define SPINOR_REG_CYPRESS_VREG                 0x00800000
  18 #define SPINOR_REG_CYPRESS_STR1                 0x0
  19 #define SPINOR_REG_CYPRESS_STR1V                                        \
  20         (SPINOR_REG_CYPRESS_VREG + SPINOR_REG_CYPRESS_STR1)
  21 #define SPINOR_REG_CYPRESS_CFR1                 0x2
  22 #define SPINOR_REG_CYPRESS_CFR1V                                        \
  23         (SPINOR_REG_CYPRESS_VREG + SPINOR_REG_CYPRESS_CFR1)
  24 #define SPINOR_REG_CYPRESS_CFR1_QUAD_EN         BIT(1)  /* Quad Enable */
  25 #define SPINOR_REG_CYPRESS_CFR2                 0x3
  26 #define SPINOR_REG_CYPRESS_CFR2V                                        \
  27         (SPINOR_REG_CYPRESS_VREG + SPINOR_REG_CYPRESS_CFR2)
  28 #define SPINOR_REG_CYPRESS_CFR2_MEMLAT_11_24    0xb
  29 #define SPINOR_REG_CYPRESS_CFR2_ADRBYT          BIT(7)
  30 #define SPINOR_REG_CYPRESS_CFR3                 0x4
  31 #define SPINOR_REG_CYPRESS_CFR3V                                        \
  32         (SPINOR_REG_CYPRESS_VREG + SPINOR_REG_CYPRESS_CFR3)
  33 #define SPINOR_REG_CYPRESS_CFR3_PGSZ            BIT(4) /* Page size. */
  34 #define SPINOR_REG_CYPRESS_CFR5                 0x6
  35 #define SPINOR_REG_CYPRESS_CFR5V                                        \
  36         (SPINOR_REG_CYPRESS_VREG + SPINOR_REG_CYPRESS_CFR5)
  37 #define SPINOR_REG_CYPRESS_CFR5_BIT6            BIT(6)
  38 #define SPINOR_REG_CYPRESS_CFR5_DDR             BIT(1)
  39 #define SPINOR_REG_CYPRESS_CFR5_OPI             BIT(0)
  40 #define SPINOR_REG_CYPRESS_CFR5_OCT_DTR_EN                              \
  41         (SPINOR_REG_CYPRESS_CFR5_BIT6 | SPINOR_REG_CYPRESS_CFR5_DDR |   \
  42          SPINOR_REG_CYPRESS_CFR5_OPI)
  43 #define SPINOR_REG_CYPRESS_CFR5_OCT_DTR_DS      SPINOR_REG_CYPRESS_CFR5_BIT6
  44 #define SPINOR_OP_CYPRESS_RD_FAST               0xee
  45 #define SPINOR_REG_CYPRESS_ARCFN                0x00000006
  46
  47 /* Cypress SPI NOR flash operations. */
  48 #define CYPRESS_NOR_WR_ANY_REG_OP(naddr, addr, ndata, buf)              \
  49         SPI_MEM_OP(SPI_MEM_OP_CMD(SPINOR_OP_WR_ANY_REG, 0),             \
  50                    SPI_MEM_OP_ADDR(naddr, addr, 0),                     \
  51                    SPI_MEM_OP_NO_DUMMY,                                 \
  52                    SPI_MEM_OP_DATA_OUT(ndata, buf, 0))
  53
  54 #define CYPRESS_NOR_RD_ANY_REG_OP(naddr, addr, ndummy, buf)             \
  55         SPI_MEM_OP(SPI_MEM_OP_CMD(SPINOR_OP_RD_ANY_REG, 0),             \
  56                    SPI_MEM_OP_ADDR(naddr, addr, 0),                     \
  57                    SPI_MEM_OP_DUMMY(ndummy, 0),                         \
  58                    SPI_MEM_OP_DATA_IN(1, buf, 0))
  59
  60 #define SPANSION_CLSR_OP                                                \
  61         SPI_MEM_OP(SPI_MEM_OP_CMD(SPINOR_OP_CLSR, 0),                   \
  62                    SPI_MEM_OP_NO_ADDR,                                  \
  63                    SPI_MEM_OP_NO_DUMMY,                                 \
  64                    SPI_MEM_OP_NO_DATA)
  65
  66 /**
  67  * spansion_nor_clear_sr() - Clear the Status Register.
  68  * @nor:        pointer to 'struct spi_nor'.
  69  */
  70 static void spansion_nor_clear_sr(struct spi_nor *nor)
  71 {
  72         int ret;
  73
  74         if (nor->spimem) {
  75                 struct spi_mem_op op = SPANSION_CLSR_OP;
  76
  77                 spi_nor_spimem_setup_op(nor, &op, nor->reg_proto);
  78
  79                 ret = spi_mem_exec_op(nor->spimem, &op);
  80         } else {
  81                 ret = spi_nor_controller_ops_write_reg(nor, SPINOR_OP_CLSR,
  82                                                        NULL, 0);
  83         }
  84
  85         if (ret)
  86                 dev_dbg(nor->dev, "error %d clearing SR\n", ret);
  87 }
  88
  89 static int cypress_nor_sr_ready_and_clear_reg(struct spi_nor *nor, u64 addr)
  90 {
  91         struct spi_mem_op op =
  92                 CYPRESS_NOR_RD_ANY_REG_OP(nor->params->addr_mode_nbytes, addr,
  93                                           0, nor->bouncebuf);
  94         int ret;
  95
  96         ret = spi_nor_read_any_reg(nor, &op, nor->reg_proto);
  97         if (ret)
  98                 return ret;
  99
 100         if (nor->bouncebuf[0] & (SR_E_ERR | SR_P_ERR)) {
 101                 if (nor->bouncebuf[0] & SR_E_ERR)
 102                         dev_err(nor->dev, "Erase Error occurred\n");
 103                 else
 104                         dev_err(nor->dev, "Programming Error occurred\n");
 105
 106                 spansion_nor_clear_sr(nor);
 107
 108                 ret = spi_nor_write_disable(nor);
 109                 if (ret)
 110                         return ret;
 111
 112                 return -EIO;
 113         }
 114
 115         return !(nor->bouncebuf[0] & SR_WIP);
 116 }
 117 /**
 118  * cypress_nor_sr_ready_and_clear() - Query the Status Register of each die by
 119  * using Read Any Register command to see if the whole flash is ready for new
 120  * commands and clear it if there are any errors.
 121  * @nor:        pointer to 'struct spi_nor'.
 122  *
 123  * Return: 1 if ready, 0 if not ready, -errno on errors.
 124  */
 125 static int cypress_nor_sr_ready_and_clear(struct spi_nor *nor)
 126 {
 127         struct spi_nor_flash_parameter *params = nor->params;
 128         u64 addr;
 129         int ret;
 130         u8 i;
 131
 132         for (i = 0; i < params->n_dice; i++) {
 133                 addr = params->vreg_offset[i] + SPINOR_REG_CYPRESS_STR1;
 134                 ret = cypress_nor_sr_ready_and_clear_reg(nor, addr);
 135                 if (ret < 0)
 136                         return ret;
 137                 else if (ret == 0)
 138                         return 0;
 139         }
 140
 141         return 1;
 142 }
 143
 144 static int cypress_nor_octal_dtr_en(struct spi_nor *nor)
 145 {
 146         struct spi_mem_op op;
 147         u8 *buf = nor->bouncebuf;
 148         int ret;
 149         u8 addr_mode_nbytes = nor->params->addr_mode_nbytes;
 150
 151         /* Use 24 dummy cycles for memory array reads. */
 152         *buf = SPINOR_REG_CYPRESS_CFR2_MEMLAT_11_24;
 153         op = (struct spi_mem_op)
 154                 CYPRESS_NOR_WR_ANY_REG_OP(addr_mode_nbytes,
 155                                           SPINOR_REG_CYPRESS_CFR2V, 1, buf);
 156
 157         ret = spi_nor_write_any_volatile_reg(nor, &op, nor->reg_proto);
 158         if (ret)
 159                 return ret;
 160
 161         nor->read_dummy = 24;
 162
 163         /* Set the octal and DTR enable bits. */
 164         buf[0] = SPINOR_REG_CYPRESS_CFR5_OCT_DTR_EN;
 165         op = (struct spi_mem_op)
 166                 CYPRESS_NOR_WR_ANY_REG_OP(addr_mode_nbytes,
 167                                           SPINOR_REG_CYPRESS_CFR5V, 1, buf);
 168
 169         ret = spi_nor_write_any_volatile_reg(nor, &op, nor->reg_proto);
 170         if (ret)
 171                 return ret;
 172
 173         /* Read flash ID to make sure the switch was successful. */
 174         ret = spi_nor_read_id(nor, nor->addr_nbytes, 3, buf,
 175                               SNOR_PROTO_8_8_8_DTR);
 176         if (ret) {
 177                 dev_dbg(nor->dev, "error %d reading JEDEC ID after enabling 8D-8D-8D mode\n", ret);
 178                 return ret;
 179         }
 180
 181         if (memcmp(buf, nor->info->id, nor->info->id_len))
 182                 return -EINVAL;
 183
 184         return 0;
 185 }
 186
 187 static int cypress_nor_octal_dtr_dis(struct spi_nor *nor)
 188 {
 189         struct spi_mem_op op;
 190         u8 *buf = nor->bouncebuf;
 191         int ret;
 192
 193         /*
 194          * The register is 1-byte wide, but 1-byte transactions are not allowed
 195          * in 8D-8D-8D mode. Since there is no register at the next location,
 196          * just initialize the value to 0 and let the transaction go on.
 197          */
 198         buf[0] = SPINOR_REG_CYPRESS_CFR5_OCT_DTR_DS;
 199         buf[1] = 0;
 200         op = (struct spi_mem_op)
 201                 CYPRESS_NOR_WR_ANY_REG_OP(nor->addr_nbytes,
 202                                           SPINOR_REG_CYPRESS_CFR5V, 2, buf);
 203         ret = spi_nor_write_any_volatile_reg(nor, &op, SNOR_PROTO_8_8_8_DTR);
 204         if (ret)
 205                 return ret;
 206
 207         /* Read flash ID to make sure the switch was successful. */
 208         ret = spi_nor_read_id(nor, 0, 0, buf, SNOR_PROTO_1_1_1);
 209         if (ret) {
 210                 dev_dbg(nor->dev, "error %d reading JEDEC ID after disabling 8D-8D-8D mode\n", ret);
 211                 return ret;
 212         }
 213
 214         if (memcmp(buf, nor->info->id, nor->info->id_len))
 215                 return -EINVAL;
 216
 217         return 0;
 218 }
 219
 220 static int cypress_nor_quad_enable_volatile_reg(struct spi_nor *nor, u64 addr)
 221 {
 222         struct spi_mem_op op;
 223         u8 addr_mode_nbytes = nor->params->addr_mode_nbytes;
 224         u8 cfr1v_written;
 225         int ret;
 226
 227         op = (struct spi_mem_op)
 228                 CYPRESS_NOR_RD_ANY_REG_OP(addr_mode_nbytes, addr, 0,
 229                                           nor->bouncebuf);
 230
 231         ret = spi_nor_read_any_reg(nor, &op, nor->reg_proto);
 232         if (ret)
 233                 return ret;
 234
 235         if (nor->bouncebuf[0] & SPINOR_REG_CYPRESS_CFR1_QUAD_EN)
 236                 return 0;
 237
 238         /* Update the Quad Enable bit. */
 239         nor->bouncebuf[0] |= SPINOR_REG_CYPRESS_CFR1_QUAD_EN;
 240         op = (struct spi_mem_op)
 241                 CYPRESS_NOR_WR_ANY_REG_OP(addr_mode_nbytes, addr, 1,
 242                                           nor->bouncebuf);
 243         ret = spi_nor_write_any_volatile_reg(nor, &op, nor->reg_proto);
 244         if (ret)
 245                 return ret;
 246
 247         cfr1v_written = nor->bouncebuf[0];
 248
 249         /* Read back and check it. */
 250         op = (struct spi_mem_op)
 251                 CYPRESS_NOR_RD_ANY_REG_OP(addr_mode_nbytes, addr, 0,
 252                                           nor->bouncebuf);
 253         ret = spi_nor_read_any_reg(nor, &op, nor->reg_proto);
 254         if (ret)
 255                 return ret;
 256
 257         if (nor->bouncebuf[0] != cfr1v_written) {
 258                 dev_err(nor->dev, "CFR1: Read back test failed\n");
 259                 return -EIO;
 260         }
 261
 262         return 0;
 263 }
 264
 265 /**
 266  * cypress_nor_quad_enable_volatile() - enable Quad I/O mode in volatile
 267  *                                      register.
 268  * @nor:        pointer to a 'struct spi_nor'
 269  *
 270  * It is recommended to update volatile registers in the field application due
 271  * to a risk of the non-volatile registers corruption by power interrupt. This
 272  * function sets Quad Enable bit in CFR1 volatile. If users set the Quad Enable
 273  * bit in the CFR1 non-volatile in advance (typically by a Flash programmer
 274  * before mounting Flash on PCB), the Quad Enable bit in the CFR1 volatile is
 275  * also set during Flash power-up.
 276  *
 277  * Return: 0 on success, -errno otherwise.
 278  */
 279 static int cypress_nor_quad_enable_volatile(struct spi_nor *nor)
 280 {
 281         struct spi_nor_flash_parameter *params = nor->params;
 282         u64 addr;
 283         u8 i;
 284         int ret;
 285
 286         if (!params->n_dice)
 287                 return cypress_nor_quad_enable_volatile_reg(nor,
 288                                                 SPINOR_REG_CYPRESS_CFR1V);
 289
 290         for (i = 0; i < params->n_dice; i++) {
 291                 addr = params->vreg_offset[i] + SPINOR_REG_CYPRESS_CFR1;
 292                 ret = cypress_nor_quad_enable_volatile_reg(nor, addr);
 293                 if (ret)
 294                         return ret;
 295         }
 296
 297         return 0;
 298 }
 299
 300 /**
 301  * cypress_nor_determine_addr_mode_by_sr1() - Determine current address mode
 302  *                                            (3 or 4-byte) by querying status
 303  *                                            register 1 (SR1).
 304  * @nor:                pointer to a 'struct spi_nor'
 305  * @addr_mode:          ponter to a buffer where we return the determined
 306  *                      address mode.
 307  *
 308  * This function tries to determine current address mode by comparing SR1 value
 309  * from RDSR1(no address), RDAR(3-byte address), and RDAR(4-byte address).
 310  *
 311  * Return: 0 on success, -errno otherwise.
 312  */
 313 static int cypress_nor_determine_addr_mode_by_sr1(struct spi_nor *nor,
 314                                                   u8 *addr_mode)
 315 {
 316         struct spi_mem_op op =
 317                 CYPRESS_NOR_RD_ANY_REG_OP(3, SPINOR_REG_CYPRESS_STR1V, 0,
 318                                           nor->bouncebuf);
 319         bool is3byte, is4byte;
 320         int ret;
 321
 322         ret = spi_nor_read_sr(nor, &nor->bouncebuf[1]);
 323         if (ret)
 324                 return ret;
 325
 326         ret = spi_nor_read_any_reg(nor, &op, nor->reg_proto);
 327         if (ret)
 328                 return ret;
 329
 330         is3byte = (nor->bouncebuf[0] == nor->bouncebuf[1]);
 331
 332         op = (struct spi_mem_op)
 333                 CYPRESS_NOR_RD_ANY_REG_OP(4, SPINOR_REG_CYPRESS_STR1V, 0,
 334                                           nor->bouncebuf);
 335         ret = spi_nor_read_any_reg(nor, &op, nor->reg_proto);
 336         if (ret)
 337                 return ret;
 338
 339         is4byte = (nor->bouncebuf[0] == nor->bouncebuf[1]);
 340
 341         if (is3byte == is4byte)
 342                 return -EIO;
 343         if (is3byte)
 344                 *addr_mode = 3;
 345         else
 346                 *addr_mode = 4;
 347
 348         return 0;
 349 }
 350
 351 /**
 352  * cypress_nor_set_addr_mode_nbytes() - Set the number of address bytes mode of
 353  *                                      current address mode.
 354  * @nor:                pointer to a 'struct spi_nor'
 355  *
 356  * Determine current address mode by reading SR1 with different methods, then
 357  * query CFR2V[7] to confirm. If determination is failed, force enter to 4-byte
 358  * address mode.
 359  *
 360  * Return: 0 on success, -errno otherwise.
 361  */
 362 static int cypress_nor_set_addr_mode_nbytes(struct spi_nor *nor)
 363 {
 364         struct spi_mem_op op;
 365         u8 addr_mode;
 366         int ret;
 367
 368         /*
 369          * Read SR1 by RDSR1 and RDAR(3- AND 4-byte addr). Use write enable
 370          * that sets bit-1 in SR1.
 371          */
 372         ret = spi_nor_write_enable(nor);
 373         if (ret)
 374                 return ret;
 375         ret = cypress_nor_determine_addr_mode_by_sr1(nor, &addr_mode);
 376         if (ret) {
 377                 ret = spi_nor_set_4byte_addr_mode(nor, true);
 378                 if (ret)
 379                         return ret;
 380                 return spi_nor_write_disable(nor);
 381         }
 382         ret = spi_nor_write_disable(nor);
 383         if (ret)
 384                 return ret;
 385
 386         /*
 387          * Query CFR2V and make sure no contradiction between determined address
 388          * mode and CFR2V[7].
 389          */
 390         op = (struct spi_mem_op)
 391                 CYPRESS_NOR_RD_ANY_REG_OP(addr_mode, SPINOR_REG_CYPRESS_CFR2V,
 392                                           0, nor->bouncebuf);
 393         ret = spi_nor_read_any_reg(nor, &op, nor->reg_proto);
 394         if (ret)
 395                 return ret;
 396
 397         if (nor->bouncebuf[0] & SPINOR_REG_CYPRESS_CFR2_ADRBYT) {
 398                 if (addr_mode != 4)
 399                         return spi_nor_set_4byte_addr_mode(nor, true);
 400         } else {
 401                 if (addr_mode != 3)
 402                         return spi_nor_set_4byte_addr_mode(nor, true);
 403         }
 404
 405         nor->params->addr_nbytes = addr_mode;
 406         nor->params->addr_mode_nbytes = addr_mode;
 407
 408         return 0;
 409 }
 410
 411 static int cypress_nor_get_page_size_single_chip(struct spi_nor *nor)
 412 {
 413         struct spi_mem_op op =
 414                 CYPRESS_NOR_RD_ANY_REG_OP(nor->params->addr_mode_nbytes,
 415                                           SPINOR_REG_CYPRESS_CFR3V, 0,
 416                                           nor->bouncebuf);
 417         int ret;
 418
 419         ret = spi_nor_read_any_reg(nor, &op, nor->reg_proto);
 420         if (ret)
 421                 return ret;
 422
 423         if (nor->bouncebuf[0] & SPINOR_REG_CYPRESS_CFR3_PGSZ)
 424                 nor->params->page_size = 512;
 425         else
 426                 nor->params->page_size = 256;
 427
 428         return 0;
 429 }
 430
 431
 432 static int cypress_nor_get_page_size_mcp(struct spi_nor *nor)
 433 {
 434         struct spi_mem_op op =
 435                 CYPRESS_NOR_RD_ANY_REG_OP(nor->params->addr_mode_nbytes,
 436                                           0, 0, nor->bouncebuf);
 437         struct spi_nor_flash_parameter *params = nor->params;
 438         int ret;
 439         u8 i;
 440
 441         /*
 442          * Use the minimum common page size configuration. Programming 256-byte
 443          * under 512-byte page size configuration is safe.
 444          */
 445         params->page_size = 256;
 446         for (i = 0; i < params->n_dice; i++) {
 447                 op.addr.val = params->vreg_offset[i] + SPINOR_REG_CYPRESS_CFR3;
 448
 449                 ret = spi_nor_read_any_reg(nor, &op, nor->reg_proto);
 450                 if (ret)
 451                         return ret;
 452
 453                 if (!(nor->bouncebuf[0] & SPINOR_REG_CYPRESS_CFR3_PGSZ))
 454                         return 0;
 455         }
 456
 457         params->page_size = 512;
 458
 459         return 0;
 460 }
 461
 462 /**
 463  * cypress_nor_get_page_size() - Get flash page size configuration.
 464  * @nor:        pointer to a 'struct spi_nor'
 465  *
 466  * The BFPT table advertises a 512B or 256B page size depending on part but the
 467  * page size is actually configurable (with the default being 256B). Read from
 468  * CFR3V[4] and set the correct size.
 469  *
 470  * Return: 0 on success, -errno otherwise.
 471  */
 472 static int cypress_nor_get_page_size(struct spi_nor *nor)
 473 {
 474         if (nor->params->n_dice)
 475                 return cypress_nor_get_page_size_mcp(nor);
 476         return cypress_nor_get_page_size_single_chip(nor);
 477 }
 478
 479 static void cypress_nor_ecc_init(struct spi_nor *nor)
 480 {
 481         /*
 482          * Programming is supported only in 16-byte ECC data unit granularity.
 483          * Byte-programming, bit-walking, or multiple program operations to the
 484          * same ECC data unit without an erase are not allowed.
 485          */
 486         nor->params->writesize = 16;
 487         nor->flags |= SNOR_F_ECC;
 488 }
 489
 490 static int
 491 s25fs256t_post_bfpt_fixup(struct spi_nor *nor,
 492                           const struct sfdp_parameter_header *bfpt_header,
 493                           const struct sfdp_bfpt *bfpt)
 494 {
 495         struct spi_mem_op op;
 496         int ret;
 497
 498         ret = cypress_nor_set_addr_mode_nbytes(nor);
 499         if (ret)
 500                 return ret;
 501
 502         /* Read Architecture Configuration Register (ARCFN) */
 503         op = (struct spi_mem_op)
 504                 CYPRESS_NOR_RD_ANY_REG_OP(nor->params->addr_mode_nbytes,
 505                                           SPINOR_REG_CYPRESS_ARCFN, 1,
 506                                           nor->bouncebuf);
 507         ret = spi_nor_read_any_reg(nor, &op, nor->reg_proto);
 508         if (ret)
 509                 return ret;
 510
 511         /* ARCFN value must be 0 if uniform sector is selected  */
 512         if (nor->bouncebuf[0])
 513                 return -ENODEV;
 514
 515         return cypress_nor_get_page_size(nor);
 516 }
 517
 518 static int s25fs256t_post_sfdp_fixup(struct spi_nor *nor)
 519 {
 520         struct spi_nor_flash_parameter *params = nor->params;
 521
 522         /* PP_1_1_4_4B is supported but missing in 4BAIT. */
 523         params->hwcaps.mask |= SNOR_HWCAPS_PP_1_1_4;
 524         spi_nor_set_pp_settings(&params->page_programs[SNOR_CMD_PP_1_1_4],
 525                                 SPINOR_OP_PP_1_1_4_4B,
 526                                 SNOR_PROTO_1_1_4);
 527
 528         return 0;
 529 }
 530
 531 static void s25fs256t_late_init(struct spi_nor *nor)
 532 {
 533         cypress_nor_ecc_init(nor);
 534 }
 535
 536 static struct spi_nor_fixups s25fs256t_fixups = {
 537         .post_bfpt = s25fs256t_post_bfpt_fixup,
 538         .post_sfdp = s25fs256t_post_sfdp_fixup,
 539         .late_init = s25fs256t_late_init,
 540 };
 541
 542 static int
 543 s25hx_t_post_bfpt_fixup(struct spi_nor *nor,
 544                         const struct sfdp_parameter_header *bfpt_header,
 545                         const struct sfdp_bfpt *bfpt)
 546 {
 547         int ret;
 548
 549         ret = cypress_nor_set_addr_mode_nbytes(nor);
 550         if (ret)
 551                 return ret;
 552
 553         /* Replace Quad Enable with volatile version */
 554         nor->params->quad_enable = cypress_nor_quad_enable_volatile;
 555
 556         return 0;
 557 }
 558
 559 static int s25hx_t_post_sfdp_fixup(struct spi_nor *nor)
 560 {
 561         struct spi_nor_erase_type *erase_type =
 562                                         nor->params->erase_map.erase_type;
 563         unsigned int i;
 564
 565         /*
 566          * In some parts, 3byte erase opcodes are advertised by 4BAIT.
 567          * Convert them to 4byte erase opcodes.
 568          */
 569         for (i = 0; i < SNOR_ERASE_TYPE_MAX; i++) {
 570                 switch (erase_type[i].opcode) {
 571                 case SPINOR_OP_SE:
 572                         erase_type[i].opcode = SPINOR_OP_SE_4B;
 573                         break;
 574                 case SPINOR_OP_BE_4K:
 575                         erase_type[i].opcode = SPINOR_OP_BE_4K_4B;
 576                         break;
 577                 default:
 578                         break;
 579                 }
 580         }
 581
 582         /* The 2 Gb parts duplicate info and advertise 4 dice instead of 2. */
 583         if (nor->params->size == SZ_256M)
 584                 nor->params->n_dice = 2;
 585
 586         return cypress_nor_get_page_size(nor);
 587 }
 588
 589 static void s25hx_t_late_init(struct spi_nor *nor)
 590 {
 591         struct spi_nor_flash_parameter *params = nor->params;
 592
 593         /* Fast Read 4B requires mode cycles */
 594         params->reads[SNOR_CMD_READ_FAST].num_mode_clocks = 8;
 595
 596         cypress_nor_ecc_init(nor);
 597
 598         /* Replace ready() with multi die version */
 599         if (params->n_dice)
 600                 params->ready = cypress_nor_sr_ready_and_clear;
 601 }
 602
 603 static struct spi_nor_fixups s25hx_t_fixups = {
 604         .post_bfpt = s25hx_t_post_bfpt_fixup,
 605         .post_sfdp = s25hx_t_post_sfdp_fixup,
 606         .late_init = s25hx_t_late_init,
 607 };
 608
 609 /**
 610  * cypress_nor_octal_dtr_enable() - Enable octal DTR on Cypress flashes.
 611  * @nor:                pointer to a 'struct spi_nor'
 612  * @enable:              whether to enable or disable Octal DTR
 613  *
 614  * This also sets the memory access latency cycles to 24 to allow the flash to
 615  * run at up to 200MHz.
 616  *
 617  * Return: 0 on success, -errno otherwise.
 618  */
 619 static int cypress_nor_octal_dtr_enable(struct spi_nor *nor, bool enable)
 620 {
 621         return enable ? cypress_nor_octal_dtr_en(nor) :
 622                         cypress_nor_octal_dtr_dis(nor);
 623 }
 624
 625 static int s28hx_t_post_sfdp_fixup(struct spi_nor *nor)
 626 {
 627         /*
 628          * On older versions of the flash the xSPI Profile 1.0 table has the
 629          * 8D-8D-8D Fast Read opcode as 0x00. But it actually should be 0xEE.
 630          */
 631         if (nor->params->reads[SNOR_CMD_READ_8_8_8_DTR].opcode == 0)
 632                 nor->params->reads[SNOR_CMD_READ_8_8_8_DTR].opcode =
 633                         SPINOR_OP_CYPRESS_RD_FAST;
 634
 635         /* This flash is also missing the 4-byte Page Program opcode bit. */
 636         spi_nor_set_pp_settings(&nor->params->page_programs[SNOR_CMD_PP],
 637                                 SPINOR_OP_PP_4B, SNOR_PROTO_1_1_1);
 638         /*
 639          * Since xSPI Page Program opcode is backward compatible with
 640          * Legacy SPI, use Legacy SPI opcode there as well.
 641          */
 642         spi_nor_set_pp_settings(&nor->params->page_programs[SNOR_CMD_PP_8_8_8_DTR],
 643                                 SPINOR_OP_PP_4B, SNOR_PROTO_8_8_8_DTR);
 644
 645         /*
 646          * The xSPI Profile 1.0 table advertises the number of additional
 647          * address bytes needed for Read Status Register command as 0 but the
 648          * actual value for that is 4.
 649          */
 650         nor->params->rdsr_addr_nbytes = 4;
 651
 652         return cypress_nor_get_page_size(nor);
 653 }
 654
 655 static int s28hx_t_post_bfpt_fixup(struct spi_nor *nor,
 656                                    const struct sfdp_parameter_header *bfpt_header,
 657                                    const struct sfdp_bfpt *bfpt)
 658 {
 659         int ret;
 660
 661         ret = cypress_nor_set_addr_mode_nbytes(nor);
 662         if (ret)
 663                 return ret;
 664
 665         return 0;
 666 }
 667
 668 static void s28hx_t_late_init(struct spi_nor *nor)
 669 {
 670         nor->params->octal_dtr_enable = cypress_nor_octal_dtr_enable;
 671         cypress_nor_ecc_init(nor);
 672 }
 673
 674 static const struct spi_nor_fixups s28hx_t_fixups = {
 675         .post_sfdp = s28hx_t_post_sfdp_fixup,
 676         .post_bfpt = s28hx_t_post_bfpt_fixup,
 677         .late_init = s28hx_t_late_init,
 678 };
 679
 680 static int
 681 s25fs_s_nor_post_bfpt_fixups(struct spi_nor *nor,
 682                              const struct sfdp_parameter_header *bfpt_header,
 683                              const struct sfdp_bfpt *bfpt)
 684 {
 685         /*
 686          * The S25FS-S chip family reports 512-byte pages in BFPT but
 687          * in reality the write buffer still wraps at the safe default
 688          * of 256 bytes.  Overwrite the page size advertised by BFPT
 689          * to get the writes working.
 690          */
 691         nor->params->page_size = 256;
 692
 693         return 0;
 694 }
 695
 696 static const struct spi_nor_fixups s25fs_s_nor_fixups = {
 697         .post_bfpt = s25fs_s_nor_post_bfpt_fixups,
 698 };
 699
 700 static const struct flash_info spansion_nor_parts[] = {
 701         /* Spansion/Cypress -- single (large) sector size only, at least
 702          * for the chips listed here (without boot sectors).
 703          */
 704         { "s25sl032p",  INFO(0x010215, 0x4d00,  64 * 1024,  64)
 705                 NO_SFDP_FLAGS(SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
 706         { "s25sl064p",  INFO(0x010216, 0x4d00,  64 * 1024, 128)
 707                 NO_SFDP_FLAGS(SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
 708         { "s25fl128s0", INFO6(0x012018, 0x4d0080, 256 * 1024, 64)
 709                 NO_SFDP_FLAGS(SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ)
 710                 MFR_FLAGS(USE_CLSR)
 711         },
 712         { "s25fl128s1", INFO6(0x012018, 0x4d0180, 64 * 1024, 256)
 713                 NO_SFDP_FLAGS(SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ)
 714                 MFR_FLAGS(USE_CLSR)
 715         },
 716         { "s25fl256s0", INFO6(0x010219, 0x4d0080, 256 * 1024, 128)
 717                 NO_SFDP_FLAGS(SPI_NOR_SKIP_SFDP | SPI_NOR_DUAL_READ |
 718                               SPI_NOR_QUAD_READ)
 719                 MFR_FLAGS(USE_CLSR)
 720         },
 721         { "s25fl256s1", INFO6(0x010219, 0x4d0180, 64 * 1024, 512)
 722                 NO_SFDP_FLAGS(SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ)
 723                 MFR_FLAGS(USE_CLSR)
 724         },
 725         { "s25fl512s",  INFO6(0x010220, 0x4d0080, 256 * 1024, 256)
 726                 FLAGS(SPI_NOR_HAS_LOCK)
 727                 NO_SFDP_FLAGS(SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ)
 728                 MFR_FLAGS(USE_CLSR)
 729         },
 730         { "s25fs128s1", INFO6(0x012018, 0x4d0181, 64 * 1024, 256)
 731                 NO_SFDP_FLAGS(SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ)
 732                 MFR_FLAGS(USE_CLSR)
 733                 .fixups = &s25fs_s_nor_fixups, },
 734         { "s25fs256s0", INFO6(0x010219, 0x4d0081, 256 * 1024, 128)
 735                 NO_SFDP_FLAGS(SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ)
 736                 MFR_FLAGS(USE_CLSR)
 737         },
 738         { "s25fs256s1", INFO6(0x010219, 0x4d0181, 64 * 1024, 512)
 739                 NO_SFDP_FLAGS(SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ)
 740                 MFR_FLAGS(USE_CLSR)
 741         },
 742         { "s25fs512s",  INFO6(0x010220, 0x4d0081, 256 * 1024, 256)
 743                 NO_SFDP_FLAGS(SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ)
 744                 MFR_FLAGS(USE_CLSR)
 745                 .fixups = &s25fs_s_nor_fixups, },
 746         { "s25sl12800", INFO(0x012018, 0x0300, 256 * 1024,  64) },
 747         { "s25sl12801", INFO(0x012018, 0x0301,  64 * 1024, 256) },
 748         { "s25fl129p0", INFO(0x012018, 0x4d00, 256 * 1024,  64)
 749                 NO_SFDP_FLAGS(SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ)
 750                 MFR_FLAGS(USE_CLSR)
 751         },
 752         { "s25fl129p1", INFO(0x012018, 0x4d01,  64 * 1024, 256)
 753                 NO_SFDP_FLAGS(SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ)
 754                 MFR_FLAGS(USE_CLSR)
 755         },
 756         { "s25sl004a",  INFO(0x010212,      0,  64 * 1024,   8) },
 757         { "s25sl008a",  INFO(0x010213,      0,  64 * 1024,  16) },
 758         { "s25sl016a",  INFO(0x010214,      0,  64 * 1024,  32) },
 759         { "s25sl032a",  INFO(0x010215,      0,  64 * 1024,  64) },
 760         { "s25sl064a",  INFO(0x010216,      0,  64 * 1024, 128) },
 761         { "s25fl004k",  INFO(0xef4013,      0,  64 * 1024,   8)
 762                 NO_SFDP_FLAGS(SECT_4K | SPI_NOR_DUAL_READ |
 763                               SPI_NOR_QUAD_READ) },
 764         { "s25fl008k",  INFO(0xef4014,      0,  64 * 1024,  16)
 765                 NO_SFDP_FLAGS(SECT_4K | SPI_NOR_DUAL_READ |
 766                               SPI_NOR_QUAD_READ) },
 767         { "s25fl016k",  INFO(0xef4015,      0,  64 * 1024,  32)
 768                 NO_SFDP_FLAGS(SECT_4K | SPI_NOR_DUAL_READ |
 769                               SPI_NOR_QUAD_READ) },
 770         { "s25fl064k",  INFO(0xef4017,      0,  64 * 1024, 128)
 771                 NO_SFDP_FLAGS(SECT_4K | SPI_NOR_DUAL_READ |
 772                               SPI_NOR_QUAD_READ) },
 773         { "s25fl116k",  INFO(0x014015,      0,  64 * 1024,  32)
 774                 NO_SFDP_FLAGS(SECT_4K | SPI_NOR_DUAL_READ |
 775                               SPI_NOR_QUAD_READ) },
 776         { "s25fl132k",  INFO(0x014016,      0,  64 * 1024,  64)
 777                 NO_SFDP_FLAGS(SECT_4K) },
 778         { "s25fl164k",  INFO(0x014017,      0,  64 * 1024, 128)
 779                 NO_SFDP_FLAGS(SECT_4K) },
 780         { "s25fl204k",  INFO(0x014013,      0,  64 * 1024,   8)
 781                 NO_SFDP_FLAGS(SECT_4K | SPI_NOR_DUAL_READ) },
 782         { "s25fl208k",  INFO(0x014014,      0,  64 * 1024,  16)
 783                 NO_SFDP_FLAGS(SECT_4K | SPI_NOR_DUAL_READ) },
 784         { "s25fl064l",  INFO(0x016017,      0,  64 * 1024, 128)
 785                 NO_SFDP_FLAGS(SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ)
 786                 FIXUP_FLAGS(SPI_NOR_4B_OPCODES) },
 787         { "s25fl128l",  INFO(0x016018,      0,  64 * 1024, 256)
 788                 NO_SFDP_FLAGS(SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ)
 789                 FIXUP_FLAGS(SPI_NOR_4B_OPCODES) },
 790         { "s25fl256l",  INFO(0x016019,      0,  64 * 1024, 512)
 791                 NO_SFDP_FLAGS(SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ)
 792                 FIXUP_FLAGS(SPI_NOR_4B_OPCODES) },
 793         { "s25fs256t",  INFO6(0x342b19, 0x0f0890, 0, 0)
 794                 PARSE_SFDP
 795                 .fixups = &s25fs256t_fixups },
 796         { "s25hl512t",  INFO6(0x342a1a, 0x0f0390, 256 * 1024, 256)
 797                 PARSE_SFDP
 798                 MFR_FLAGS(USE_CLSR)
 799                 .fixups = &s25hx_t_fixups },
 800         { "s25hl01gt",  INFO6(0x342a1b, 0x0f0390, 256 * 1024, 512)
 801                 PARSE_SFDP
 802                 MFR_FLAGS(USE_CLSR)
 803                 .fixups = &s25hx_t_fixups },
 804         { "s25hl02gt",  INFO6(0x342a1c, 0x0f0090, 0, 0)
 805                 PARSE_SFDP
 806                 FLAGS(NO_CHIP_ERASE)
 807                 .fixups = &s25hx_t_fixups },
 808         { "s25hs512t",  INFO6(0x342b1a, 0x0f0390, 256 * 1024, 256)
 809                 PARSE_SFDP
 810                 MFR_FLAGS(USE_CLSR)
 811                 .fixups = &s25hx_t_fixups },
 812         { "s25hs01gt",  INFO6(0x342b1b, 0x0f0390, 256 * 1024, 512)
 813                 PARSE_SFDP
 814                 MFR_FLAGS(USE_CLSR)
 815                 .fixups = &s25hx_t_fixups },
 816         { "s25hs02gt",  INFO6(0x342b1c, 0x0f0090, 0, 0)
 817                 PARSE_SFDP
 818                 FLAGS(NO_CHIP_ERASE)
 819                 .fixups = &s25hx_t_fixups },
 820         { "cy15x104q",  INFO6(0x042cc2, 0x7f7f7f, 512 * 1024, 1)
 821                 FLAGS(SPI_NOR_NO_ERASE) },
 822         { "s28hl512t",   INFO(0x345a1a,      0, 256 * 1024, 256)
 823                 PARSE_SFDP
 824                 .fixups = &s28hx_t_fixups,
 825         },
 826         { "s28hl01gt",   INFO(0x345a1b,      0, 256 * 1024, 512)
 827                 PARSE_SFDP
 828                 .fixups = &s28hx_t_fixups,
 829         },
 830         { "s28hs512t",   INFO(0x345b1a,      0, 256 * 1024, 256)
 831                 PARSE_SFDP
 832                 .fixups = &s28hx_t_fixups,
 833         },
 834         { "s28hs01gt",   INFO(0x345b1b,      0, 256 * 1024, 512)
 835                 PARSE_SFDP
 836                 .fixups = &s28hx_t_fixups,
 837         },
 838 };
 839
 840 /**
 841  * spansion_nor_sr_ready_and_clear() - Query the Status Register to see if the
 842  * flash is ready for new commands and clear it if there are any errors.
 843  * @nor:        pointer to 'struct spi_nor'.
 844  *
 845  * Return: 1 if ready, 0 if not ready, -errno on errors.
 846  */
 847 static int spansion_nor_sr_ready_and_clear(struct spi_nor *nor)
 848 {
 849         int ret;
 850
 851         ret = spi_nor_read_sr(nor, nor->bouncebuf);
 852         if (ret)
 853                 return ret;
 854
 855         if (nor->bouncebuf[0] & (SR_E_ERR | SR_P_ERR)) {
 856                 if (nor->bouncebuf[0] & SR_E_ERR)
 857                         dev_err(nor->dev, "Erase Error occurred\n");
 858                 else
 859                         dev_err(nor->dev, "Programming Error occurred\n");
 860
 861                 spansion_nor_clear_sr(nor);
 862
 863                 /*
 864                  * WEL bit remains set to one when an erase or page program
 865                  * error occurs. Issue a Write Disable command to protect
 866                  * against inadvertent writes that can possibly corrupt the
 867                  * contents of the memory.
 868                  */
 869                 ret = spi_nor_write_disable(nor);
 870                 if (ret)
 871                         return ret;
 872
 873                 return -EIO;
 874         }
 875
 876         return !(nor->bouncebuf[0] & SR_WIP);
 877 }
 878
 879 static void spansion_nor_late_init(struct spi_nor *nor)
 880 {
 881         if (nor->params->size > SZ_16M) {
 882                 nor->flags |= SNOR_F_4B_OPCODES;
 883                 /* No small sector erase for 4-byte command set */
 884                 nor->erase_opcode = SPINOR_OP_SE;
 885                 nor->mtd.erasesize = nor->info->sector_size;
 886         }
 887
 888         if (nor->info->mfr_flags & USE_CLSR)
 889                 nor->params->ready = spansion_nor_sr_ready_and_clear;
 890 }
 891
 892 static const struct spi_nor_fixups spansion_nor_fixups = {
 893         .late_init = spansion_nor_late_init,
 894 };
 895
 896 const struct spi_nor_manufacturer spi_nor_spansion = {
 897         .name = "spansion",
 898         .parts = spansion_nor_parts,
 899         .nparts = ARRAY_SIZE(spansion_nor_parts),
 900         .fixups = &spansion_nor_fixups,
 901 };