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