Skip to contentSkip to conversation

mtd: spi-nor: keep lock bits if they are non-volatile

PATCH Superseded Michael Walle 3 participants 17 messages Dec 2, 2020 – Dec 3, 2020

Subsystems (4)

v7 of 8 Superseded Latest is v8 →

lore
Share & tools
lore
#0 lore raw

v7 cover mtd: spi-nor: keep lock bits if they are non-volatile

I bundled this as a series, because otherwise there will be conflicts because the "remove global protection flag" patches modify the same lines as the main patch.

There are now two more patches:
mtd: spi-nor: sst: fix BPn bits for the SST25VF064C
mtd: spi-nor: ignore errors in spi_nor_unlock_all()
Both are fixes and are first in this series. This will ensure that they even have a chance to apply cleanly to the stable trees as the following patches touches the same lines.

See invdividual patches for the version history.

Michael Walle (7):
mtd: spi-nor: sst: fix BPn bits for the SST25VF064C
mtd: spi-nor: ignore errors in spi_nor_unlock_all()
mtd: spi-nor: atmel: remove global protection flag
mtd: spi-nor: sst: remove global protection flag
mtd: spi-nor: intel: remove global protection flag
mtd: spi-nor: atmel: fix unlock_all() for AT25FS010/040
mtd: spi-nor: keep lock bits if they are non-volatile

 drivers/mtd/spi-nor/Kconfig |  44 +++++++++
 drivers/mtd/spi-nor/atmel.c | 191 ++++++++++++++++++++++++++++++++----
 drivers/mtd/spi-nor/core.c  |  46 ++++++---
 drivers/mtd/spi-nor/core.h  |   9 ++
 drivers/mtd/spi-nor/esmt.c  |   2 +-
 drivers/mtd/spi-nor/intel.c |  19 ++--
 drivers/mtd/spi-nor/sst.c   |  32 +++---
 7 files changed, 279 insertions(+), 64 deletions(-)
Signature · 6 lines
2.20.1


______________________________________________________
Linux MTD discussion mailing list
http://lists.infradead.org/mailman/listinfo/linux-mtd/
#1 lore raw

PATCH v7 1/7 mtd: spi-nor: sst: fix BPn bits for the SST25VF064C

This flash part actually has 4 block protection bits.

---
I didn't add the Fixes: tag because we depend on the 4bit BP support which was introduced in 5.7.

changes since v6:
- new patch

 drivers/mtd/spi-nor/sst.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)
drivers/mtd/spi-nor/sst.c +2 -1
index e0af6d25d573..0ab07624fb73 100644
@@ -18,7 +18,8 @@ static const struct flash_info sst_parts[] = {
 			      SECT_4K | SST_WRITE) },
 	{ "sst25vf032b", INFO(0xbf254a, 0, 64 * 1024, 64,
 			      SECT_4K | SST_WRITE) },
-	{ "sst25vf064c", INFO(0xbf254b, 0, 64 * 1024, 128, SECT_4K) },
+	{ "sst25vf064c", INFO(0xbf254b, 0, 64 * 1024, 128,
+			      SECT_4K | SPI_NOR_4BIT_BP) },
 	{ "sst25wf512",  INFO(0xbf2501, 0, 64 * 1024,  1,
 			      SECT_4K | SST_WRITE) },
 	{ "sst25wf010",  INFO(0xbf2502, 0, 64 * 1024,  2,
Signature · 1 line
2.20.1
Reviewed-by on v7 1/7
#2 lore raw

Re: [PATCH v7 1/7] mtd: spi-nor: sst: fix BPn bits for the SST25VF064C

Quoted 6 lines · Michael Walle

EXTERNAL EMAIL: Do not click links or open attachments unless you know the content is safe

This flash part actually has 4 block protection bits.

While the patch is correct according to the datasheet, it was not tested, so it's not a candidate for stable. I would update the commit message to indicate that the the patch was made solely on datasheet info and not tested, I would add the fixes tag, and strip cc-ing to stable.

Quoted 1 line

With the above addressed:

Quoted 25 lines

---
I didn't add the Fixes: tag because we depend on the 4bit BP support which was introduced in 5.7.

changes since v6:
- new patch

 drivers/mtd/spi-nor/sst.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)
drivers/mtd/spi-nor/sst.c +2 -2
index e0af6d25d573..0ab07624fb73 100644
@@ -18,7 +18,8 @@ static const struct flash_info sst_parts[] = {
                              SECT_4K | SST_WRITE) },
        { "sst25vf032b", INFO(0xbf254a, 0, 64 * 1024, 64,
                              SECT_4K | SST_WRITE) },
-       { "sst25vf064c", INFO(0xbf254b, 0, 64 * 1024, 128, SECT_4K) },
+       { "sst25vf064c", INFO(0xbf254b, 0, 64 * 1024, 128,
+                             SECT_4K | SPI_NOR_4BIT_BP) },
        { "sst25wf512",  INFO(0xbf2501, 0, 64 * 1024,  1,
                              SECT_4K | SST_WRITE) },
        { "sst25wf010",  INFO(0xbf2502, 0, 64 * 1024,  2,
--
Quoted 2 lines

2.20.1

______________________________________________________
Linux MTD discussion mailing list
http://lists.infradead.org/mailman/listinfo/linux-mtd/

#3 lore raw

Re: [PATCH v7 1/7] mtd: spi-nor: sst: fix BPn bits for the SST25VF064C

Am 2020-12-03 15:34, schrieb [email protected]:

Quoted 5 lines · Michael Walle
Quoted 4 lines

EXTERNAL EMAIL: Do not click links or open attachments unless you know the content is safe

This flash part actually has 4 block protection bits.

Quoted 8 lines
Quoted 2 lines

While the patch is correct according to the datasheet, it was not tested, so it's not a candidate for stable. I would update the commit message to indicate that the the patch was made solely on datasheet info and not tested, I would add the fixes tag, and strip cc-ing to stable.

What is the difference? Any commit with a Fixes tag will also land in the stable trees. Just that it will cause compile errors for kernel older than 5.7.

So if you don't want to have it in stable then you must not add a Fixes: tag either.

-michael

______________________________________________________
Linux MTD discussion mailing list
http://lists.infradead.org/mailman/listinfo/linux-mtd/

#4 lore raw

Re: [PATCH v7 1/7] mtd: spi-nor: sst: fix BPn bits for the SST25VF064C

Quoted 18 lines · Michael Walle

EXTERNAL EMAIL: Do not click links or open attachments unless you know the content is safe

Am 2020-12-03 15:34, schrieb [email protected]:

Quoted 6 lines · Michael Walle
Quoted 5 lines

EXTERNAL EMAIL: Do not click links or open attachments unless you know the content is safe

This flash part actually has 4 block protection bits.

Quoted 8 lines
Quoted 2 lines

While the patch is correct according to the datasheet, it was not tested, so it's not a candidate for stable. I would update the commit message to indicate that the the patch was made solely on datasheet info and not tested, I would add the fixes tag, and strip cc-ing to stable.

Quoted 7 lines

What is the difference? Any commit with a Fixes tag will also land in the stable trees. Just that it will cause compile errors for kernel older than 5.7.

So if you don't want to have it in stable then you must not add a Fixes: tag either.

Documentation/process/stable-kernel-rules.rst doesn't say that the Fixes tag is a guarantee that a patch will hit the stable kernels.

Since this patch was not tested, it's not a candidate for stable as per the first rule. It's a theoretical fix, because it should indeed fix the locking as per the datasheet. Even for theoretical fixes, I would like to know what commit broke the functionality, and that's why I asked for the Fixes tag.

We don't want the patch in stable, so that's why I said that I would indicate in the commit message that it was not tested, and that I would strip the cc to stable.

Maybe it's just my understanding. Others may help.
______________________________________________________
Linux MTD discussion mailing list
http://lists.infradead.org/mailman/listinfo/linux-mtd/

maintainer
#5 lore raw

Re: [PATCH v7 1/7] mtd: spi-nor: sst: fix BPn bits for the SST25VF064C

Quoted 36 lines · On Thu, Dec 03, 2020 at 03:08:49PM +0000, [email protected] wrote:
Quoted 18 lines · Michael Walle

EXTERNAL EMAIL: Do not click links or open attachments unless you know the content is safe

Am 2020-12-03 15:34, schrieb [email protected]:

Quoted 6 lines · Michael Walle
Quoted 5 lines

EXTERNAL EMAIL: Do not click links or open attachments unless you know the content is safe

This flash part actually has 4 block protection bits.

Quoted 8 lines
Quoted 2 lines

While the patch is correct according to the datasheet, it was not tested, so it's not a candidate for stable. I would update the commit message to indicate that the the patch was made solely on datasheet info and not tested, I would add the fixes tag, and strip cc-ing to stable.

Quoted 7 lines

What is the difference? Any commit with a Fixes tag will also land in the stable trees. Just that it will cause compile errors for kernel older than 5.7.

So if you don't want to have it in stable then you must not add a Fixes: tag either.

Documentation/process/stable-kernel-rules.rst doesn't say that the Fixes tag is a guarantee that a patch will hit the stable kernels.

Since this patch was not tested, it's not a candidate for stable as per the first rule. It's a theoretical fix, because it should indeed fix the locking as per the datasheet. Even for theoretical fixes, I would like to know what commit broke the functionality, and that's why I asked for the Fixes tag.

Quoted 5 lines

We don't want the patch in stable, so that's why I said that I would indicate in the commit message that it was not tested, and that I would strip the cc to stable.

Maybe it's just my understanding. Others may help.

Your understanding is correct. But note that we might accidentally pick it up with the Fixes: tag at a later date, so be aware that you might want to make the text in the changelog really obvious that it should not go into a stable kernel, and why not (hint, if you have a Fixes: tag, that's usually a good reason _to_ include it...)

thanks,

greg k-h

______________________________________________________
Linux MTD discussion mailing list
http://lists.infradead.org/mailman/listinfo/linux-mtd/

#6 lore raw

Re: [PATCH v7 1/7] mtd: spi-nor: sst: fix BPn bits for the SST25VF064C

In reply to Michael Walle

drivers/mtd/spi-nor/sst.c static const struct flash_info sst_parts[] = { · line 22

Quoted 9 lines · Michael Walle
drivers/mtd/spi-nor/sst.c +2 -1
@@ -18,7 +18,8 @@ static const struct flash_info sst_parts[] = {
                              SECT_4K | SST_WRITE) },
        { "sst25vf032b", INFO(0xbf254a, 0, 64 * 1024, 64,
                              SECT_4K | SST_WRITE) },
-       { "sst25vf064c", INFO(0xbf254b, 0, 64 * 1024, 128, SECT_4K) },
+       { "sst25vf064c", INFO(0xbf254b, 0, 64 * 1024, 128,
+                             SECT_4K | SPI_NOR_4BIT_BP) },

And I would put 1/7 after 4/7, so that I can set the locking flags in some order: SPI_NOR_HAS_LOCK | SPI_NOR_4BIT_BP. We first indicate that the flash supports locking, and then what kind of locking, BP3, and not the other way around.

anyway, just cosmetics

______________________________________________________
Linux MTD discussion mailing list
http://lists.infradead.org/mailman/listinfo/linux-mtd/

#7 lore raw

Re: [PATCH v7 1/7] mtd: spi-nor: sst: fix BPn bits for the SST25VF064C

Am 2020-12-03 15:40, schrieb [email protected]:

Quoted 7 lines · Michael Walle
Quoted 6 lines
drivers/mtd/spi-nor/sst.c +0 -0
@@ -18,7 +18,8 @@ static const struct flash_info sst_parts[] = {
                              SECT_4K | SST_WRITE) },
        { "sst25vf032b", INFO(0xbf254a, 0, 64 * 1024, 64,
                              SECT_4K | SST_WRITE) },
Quoted 8 lines

drivers/mtd/spi-nor/sst.c static const struct flash_info sst_parts[] = { · line 22

Quoted 3 lines
drivers/mtd/spi-nor/sst.c +2 -1
-       { "sst25vf064c", INFO(0xbf254b, 0, 64 * 1024, 128, SECT_4K) },
+       { "sst25vf064c", INFO(0xbf254b, 0, 64 * 1024, 128,
+                             SECT_4K | SPI_NOR_4BIT_BP) },

And I would put 1/7 after 4/7, so that I can set the locking flags in some order: SPI_NOR_HAS_LOCK | SPI_NOR_4BIT_BP. We first indicate that the flash supports locking, and then what kind of locking, BP3, and not the other way around.

If that patch shouldn't make it into stable, then yes. otherwise, I've put these patches first to not cause merge conflicts.

-michael

______________________________________________________
Linux MTD discussion mailing list
http://lists.infradead.org/mailman/listinfo/linux-mtd/

#8 lore raw

PATCH v7 2/7 mtd: spi-nor: ignore errors in spi_nor_unlock_all()

In reply to Michael Walle

Just try to unlock the whole SPI-NOR flash array. Don't abort the probing in case of an error. Justifications:
(1) For some boards, this just works because spi_nor_write_16bit_sr_and_check() is broken and just checks the second half of the 16bit. Once that will be fixed, SPI probe will fail for boards which has hardware-write protected SPI-NOR flashes.
(2) Until now, hardware write-protection was the only viable solution to use the block protection bits. This is because this very function spi_nor_unlock_all() will be called unconditionally on every linux boot. Therefore, this bits only makes sense in combination with the hardware write-protection. If we would fail the SPI probe on an error in spi_nor_unlock_all() we'd break virtually all users of the block protection bits.
(3) We should try hard to keep the MTD working even if the flash might not be writable/erasable.

Fixes 3e0930f109e7 ("mtd: spi-nor: Rework the disabling of block write protection")

---
changes since v6:
- new patch

 drivers/mtd/spi-nor/core.c | 23 +++++++++++++----------
 1 file changed, 13 insertions(+), 10 deletions(-)
drivers/mtd/spi-nor/core.c +13 -10
index 5bee7c8da4dc..013198abe929 100644
@@ -3121,20 +3121,27 @@ static int spi_nor_quad_enable(struct spi_nor *nor)
 }
 
 /**
- * spi_nor_unlock_all() - Unlocks the entire flash memory array.
+ * spi_nor_try_unlock_all() - Tries to unlock the entire flash memory array.
  * @nor:	pointer to a 'struct spi_nor'.
  *
  * Some SPI NOR flashes are write protected by default after a power-on reset
  * cycle, in order to avoid inadvertent writes during power-up. Backward
  * compatibility imposes to unlock the entire flash memory array at power-up
  * by default.
+ *
+ * Unprotecting the entire flash array will fail for boards which are hardware
+ * write-protected. Thus any errors are ignored.
  */
-static int spi_nor_unlock_all(struct spi_nor *nor)
+static void spi_nor_try_unlock_all(struct spi_nor *nor)
 {
-	if (nor->flags & SNOR_F_HAS_LOCK)
-		return spi_nor_unlock(&nor->mtd, 0, nor->params->size);
+	int ret;
 
-	return 0;
+	if (!(nor->flags & SNOR_F_HAS_LOCK))
+		return;
+
+	ret = spi_nor_unlock(&nor->mtd, 0, nor->params->size);
+	if (ret)
+		dev_dbg(nor->dev, "Failed to unlock the entire flash memory array\n");
 }
 
 static int spi_nor_init(struct spi_nor *nor)
@@ -3153,11 +3160,7 @@ static int spi_nor_init(struct spi_nor *nor)
 		return err;
 	}
 
-	err = spi_nor_unlock_all(nor);
-	if (err) {
-		dev_dbg(nor->dev, "Failed to unlock the entire flash memory array\n");
-		return err;
-	}
+	spi_nor_try_unlock_all(nor);
 
 	if (nor->addr_width == 4 &&
 	    nor->read_proto != SNOR_PROTO_8_8_8_DTR &&
Signature · 6 lines
2.20.1


______________________________________________________
Linux MTD discussion mailing list
http://lists.infradead.org/mailman/listinfo/linux-mtd/
Reviewed-by on v7 2/7
#9 lore raw

Re: [PATCH v7 2/7] mtd: spi-nor: ignore errors in spi_nor_unlock_all()

Quoted 18 lines · Michael Walle

EXTERNAL EMAIL: Do not click links or open attachments unless you know the content is safe

Just try to unlock the whole SPI-NOR flash array. Don't abort the probing in case of an error. Justifications:
(1) For some boards, this just works because spi_nor_write_16bit_sr_and_check() is broken and just checks the second half of the 16bit. Once that will be fixed, SPI probe will fail for boards which has hardware-write protected SPI-NOR flashes.
(2) Until now, hardware write-protection was the only viable solution to use the block protection bits. This is because this very function spi_nor_unlock_all() will be called unconditionally on every linux boot. Therefore, this bits only makes sense in combination with the hardware write-protection. If we would fail the SPI probe on an error in spi_nor_unlock_all() we'd break virtually all users of the block protection bits.
(3) We should try hard to keep the MTD working even if the flash might not be writable/erasable.

Quoted 2 lines
Fixes 3e0930f109e7 ("mtd: spi-nor: Rework the disabling of block write protection")
Quoted 60 lines

---
changes since v6:
- new patch

 drivers/mtd/spi-nor/core.c | 23 +++++++++++++----------
 1 file changed, 13 insertions(+), 10 deletions(-)
drivers/mtd/spi-nor/core.c +13 -11
index 5bee7c8da4dc..013198abe929 100644
@@ -3121,20 +3121,27 @@ static int spi_nor_quad_enable(struct spi_nor *nor)
 }
 
 /**
- * spi_nor_unlock_all() - Unlocks the entire flash memory array.
+ * spi_nor_try_unlock_all() - Tries to unlock the entire flash memory array.
  * @nor:       pointer to a 'struct spi_nor'.
  *
  * Some SPI NOR flashes are write protected by default after a power-on reset
  * cycle, in order to avoid inadvertent writes during power-up. Backward
  * compatibility imposes to unlock the entire flash memory array at power-up
  * by default.
+ *
+ * Unprotecting the entire flash array will fail for boards which are hardware
+ * write-protected. Thus any errors are ignored.
  */
-static int spi_nor_unlock_all(struct spi_nor *nor)
+static void spi_nor_try_unlock_all(struct spi_nor *nor)
 {
-       if (nor->flags & SNOR_F_HAS_LOCK)
-               return spi_nor_unlock(&nor->mtd, 0, nor->params->size);
+       int ret;
 
-       return 0;
+       if (!(nor->flags & SNOR_F_HAS_LOCK))
+               return;
+
+       ret = spi_nor_unlock(&nor->mtd, 0, nor->params->size);
+       if (ret)
+               dev_dbg(nor->dev, "Failed to unlock the entire flash memory array\n");
 }
 
 static int spi_nor_init(struct spi_nor *nor)
@@ -3153,11 +3160,7 @@ static int spi_nor_init(struct spi_nor *nor)
                return err;
        }
 
-       err = spi_nor_unlock_all(nor);
-       if (err) {
-               dev_dbg(nor->dev, "Failed to unlock the entire flash memory array\n");
-               return err;
-       }
+       spi_nor_try_unlock_all(nor);
 
        if (nor->addr_width == 4 &&
            nor->read_proto != SNOR_PROTO_8_8_8_DTR &&
--

2.20.1

#10 lore raw

PATCH v7 3/7 mtd: spi-nor: atmel: remove global protection flag

In reply to Michael Walle

This is considered bad for the following reasons:
(1) We only support the block protection with BPn bits for write protection. Not all Atmel parts support this.
(2) Newly added flash chip will automatically inherit the "has locking" support and thus needs to explicitly tested. Better be opt-in instead of opt-out.
(3) There are already supported flashes which doesn't support the locking scheme. So I assume this wasn't properly tested before adding that chip; which enforces my previous argument that locking support should be an opt-in.

Remove the global flag and add individual flags to all flashes which supports BP locking. In particular the following flashes don't support the BP scheme:
- AT26F004
- AT25SL321
- AT45DB081D

Please note, that some flashes which are marked as SPI_NOR_HAS_LOCK just support Global Protection, i.e. not our supported block protection locking scheme. This is to keep backwards compatibility with the current "unlock all at boot" mechanism. In particular the following flashes doesn't have BP bits:
- AT25DF041A
- AT25DF321
- AT25DF321A
- AT25DF641
- AT26DF081A
- AT26DF161A
- AT26DF321

---
changes since v6:
- none

changes since v5:
- none

changes since v4:
- none

changes since v3/v2/v1:
- there was no such version because this patch was bundled with another patch

changes since RFC:
- mention the flashes which just support the "Global Unprotect" in the commit message

 drivers/mtd/spi-nor/atmel.c | 28 +++++++++-------------------
 1 file changed, 9 insertions(+), 19 deletions(-)
drivers/mtd/spi-nor/atmel.c +9 -19
index 3f5f21a473a6..49d392c6c8bc 100644
@@ -10,37 +10,27 @@
 
 static const struct flash_info atmel_parts[] = {
 	/* Atmel -- some are (confusingly) marketed as "DataFlash" */
-	{ "at25fs010",  INFO(0x1f6601, 0, 32 * 1024,   4, SECT_4K) },
-	{ "at25fs040",  INFO(0x1f6604, 0, 64 * 1024,   8, SECT_4K) },
+	{ "at25fs010",  INFO(0x1f6601, 0, 32 * 1024,   4, SECT_4K | SPI_NOR_HAS_LOCK) },
+	{ "at25fs040",  INFO(0x1f6604, 0, 64 * 1024,   8, SECT_4K | SPI_NOR_HAS_LOCK) },
 
-	{ "at25df041a", INFO(0x1f4401, 0, 64 * 1024,   8, SECT_4K) },
-	{ "at25df321",  INFO(0x1f4700, 0, 64 * 1024,  64, SECT_4K) },
-	{ "at25df321a", INFO(0x1f4701, 0, 64 * 1024,  64, SECT_4K) },
-	{ "at25df641",  INFO(0x1f4800, 0, 64 * 1024, 128, SECT_4K) },
+	{ "at25df041a", INFO(0x1f4401, 0, 64 * 1024,   8, SECT_4K | SPI_NOR_HAS_LOCK) },
+	{ "at25df321",  INFO(0x1f4700, 0, 64 * 1024,  64, SECT_4K | SPI_NOR_HAS_LOCK) },
+	{ "at25df321a", INFO(0x1f4701, 0, 64 * 1024,  64, SECT_4K | SPI_NOR_HAS_LOCK) },
+	{ "at25df641",  INFO(0x1f4800, 0, 64 * 1024, 128, SECT_4K | SPI_NOR_HAS_LOCK) },
 
 	{ "at25sl321",	INFO(0x1f4216, 0, 64 * 1024, 64,
 			     SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
 
 	{ "at26f004",   INFO(0x1f0400, 0, 64 * 1024,  8, SECT_4K) },
-	{ "at26df081a", INFO(0x1f4501, 0, 64 * 1024, 16, SECT_4K) },
-	{ "at26df161a", INFO(0x1f4601, 0, 64 * 1024, 32, SECT_4K) },
-	{ "at26df321",  INFO(0x1f4700, 0, 64 * 1024, 64, SECT_4K) },
+	{ "at26df081a", INFO(0x1f4501, 0, 64 * 1024, 16, SECT_4K | SPI_NOR_HAS_LOCK) },
+	{ "at26df161a", INFO(0x1f4601, 0, 64 * 1024, 32, SECT_4K | SPI_NOR_HAS_LOCK) },
+	{ "at26df321",  INFO(0x1f4700, 0, 64 * 1024, 64, SECT_4K | SPI_NOR_HAS_LOCK) },
 
 	{ "at45db081d", INFO(0x1f2500, 0, 64 * 1024, 16, SECT_4K) },
 };
 
-static void atmel_default_init(struct spi_nor *nor)
-{
-	nor->flags |= SNOR_F_HAS_LOCK;
-}
-
-static const struct spi_nor_fixups atmel_fixups = {
-	.default_init = atmel_default_init,
-};
-
 const struct spi_nor_manufacturer spi_nor_atmel = {
 	.name = "atmel",
 	.parts = atmel_parts,
 	.nparts = ARRAY_SIZE(atmel_parts),
-	.fixups = &atmel_fixups,
 };
Signature · 1 line
2.20.1
#11 lore raw

PATCH v7 4/7 mtd: spi-nor: sst: remove global protection flag

In reply to Michael Walle

This is considered bad for the following reasons:
(1) We only support the block protection with BPn bits for write protection. Not all SST parts support this.
(2) Newly added flash chip will automatically inherit the "has locking" support and thus needs to explicitly tested. Better be opt-in instead of opt-out.
(3) There are already supported flashes which doesn't support the locking scheme. So I assume this wasn't properly tested before adding that chip; which enforces my previous argument that locking support should be an opt-in.

Remove the global flag and add individual flags to all flashes which supports BP locking. In particular the following flashes don't support the BP scheme:
- SST26VF016B
- SST26WF016B
- SST26VF064B

---
changes since v6:
- none

changes since v5:
- none

changes since v4:
- none

changes since v3/v2/v1:
- there was no such version because this patch was bundled with another patch

changes since RFC:
- none

 drivers/mtd/spi-nor/sst.c | 30 ++++++++++++------------------
 1 file changed, 12 insertions(+), 18 deletions(-)
drivers/mtd/spi-nor/sst.c +12 -18
index 0ab07624fb73..0d9d319f61e6 100644
@@ -11,27 +11,27 @@
 static const struct flash_info sst_parts[] = {
 	/* SST -- large erase sizes are "overlays", "sectors" are 4K */
 	{ "sst25vf040b", INFO(0xbf258d, 0, 64 * 1024,  8,
-			      SECT_4K | SST_WRITE) },
+			      SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK) },
 	{ "sst25vf080b", INFO(0xbf258e, 0, 64 * 1024, 16,
-			      SECT_4K | SST_WRITE) },
+			      SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK) },
 	{ "sst25vf016b", INFO(0xbf2541, 0, 64 * 1024, 32,
-			      SECT_4K | SST_WRITE) },
+			      SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK) },
 	{ "sst25vf032b", INFO(0xbf254a, 0, 64 * 1024, 64,
-			      SECT_4K | SST_WRITE) },
+			      SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK) },
 	{ "sst25vf064c", INFO(0xbf254b, 0, 64 * 1024, 128,
-			      SECT_4K | SPI_NOR_4BIT_BP) },
+			      SECT_4K | SPI_NOR_4BIT_BP | SPI_NOR_HAS_LOCK) },
 	{ "sst25wf512",  INFO(0xbf2501, 0, 64 * 1024,  1,
-			      SECT_4K | SST_WRITE) },
+			      SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK) },
 	{ "sst25wf010",  INFO(0xbf2502, 0, 64 * 1024,  2,
-			      SECT_4K | SST_WRITE) },
+			      SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK) },
 	{ "sst25wf020",  INFO(0xbf2503, 0, 64 * 1024,  4,
-			      SECT_4K | SST_WRITE) },
-	{ "sst25wf020a", INFO(0x621612, 0, 64 * 1024,  4, SECT_4K) },
-	{ "sst25wf040b", INFO(0x621613, 0, 64 * 1024,  8, SECT_4K) },
+			      SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK) },
+	{ "sst25wf020a", INFO(0x621612, 0, 64 * 1024,  4, SECT_4K | SPI_NOR_HAS_LOCK) },
+	{ "sst25wf040b", INFO(0x621613, 0, 64 * 1024,  8, SECT_4K | SPI_NOR_HAS_LOCK) },
 	{ "sst25wf040",  INFO(0xbf2504, 0, 64 * 1024,  8,
-			      SECT_4K | SST_WRITE) },
+			      SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK) },
 	{ "sst25wf080",  INFO(0xbf2505, 0, 64 * 1024, 16,
-			      SECT_4K | SST_WRITE) },
+			      SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK) },
 	{ "sst26wf016b", INFO(0xbf2651, 0, 64 * 1024, 32,
 			      SECT_4K | SPI_NOR_DUAL_READ |
 			      SPI_NOR_QUAD_READ) },
@@ -128,11 +128,6 @@ static int sst_write(struct mtd_info *mtd, loff_t to, size_t len,
 	return ret;
 }
 
-static void sst_default_init(struct spi_nor *nor)
-{
-	nor->flags |= SNOR_F_HAS_LOCK;
-}
-
 static void sst_post_sfdp_fixups(struct spi_nor *nor)
 {
 	if (nor->info->flags & SST_WRITE)
@@ -140,7 +135,6 @@ static void sst_post_sfdp_fixups(struct spi_nor *nor)
 }
 
 static const struct spi_nor_fixups sst_fixups = {
-	.default_init = sst_default_init,
 	.post_sfdp = sst_post_sfdp_fixups,
 };
 
Signature · 1 line
2.20.1
#12 lore raw

PATCH v7 5/7 mtd: spi-nor: intel: remove global protection flag

In reply to Michael Walle

For the Atmel and SST parts this flag was already moved to individual flash parts because it is considered bad esp. because newer flash chips will automatically inherit the "has locking" support. While this won't likely be the case for the Intel parts, we do it for consistency reasons.

---
changes since v6
- none

changes since v5
- new patch

 drivers/mtd/spi-nor/intel.c | 16 +++-------------
 1 file changed, 3 insertions(+), 13 deletions(-)
drivers/mtd/spi-nor/intel.c +3 -13
index d8196f101368..6c31bef3fc60 100644
@@ -10,23 +10,13 @@
 
 static const struct flash_info intel_parts[] = {
 	/* Intel/Numonyx -- xxxs33b */
-	{ "160s33b",  INFO(0x898911, 0, 64 * 1024,  32, 0) },
-	{ "320s33b",  INFO(0x898912, 0, 64 * 1024,  64, 0) },
-	{ "640s33b",  INFO(0x898913, 0, 64 * 1024, 128, 0) },
-};
-
-static void intel_default_init(struct spi_nor *nor)
-{
-	nor->flags |= SNOR_F_HAS_LOCK;
-}
-
-static const struct spi_nor_fixups intel_fixups = {
-	.default_init = intel_default_init,
+	{ "160s33b",  INFO(0x898911, 0, 64 * 1024,  32, SPI_NOR_HAS_LOCK) },
+	{ "320s33b",  INFO(0x898912, 0, 64 * 1024,  64, SPI_NOR_HAS_LOCK) },
+	{ "640s33b",  INFO(0x898913, 0, 64 * 1024, 128, SPI_NOR_HAS_LOCK) },
 };
 
 const struct spi_nor_manufacturer spi_nor_intel = {
 	.name = "intel",
 	.parts = intel_parts,
 	.nparts = ARRAY_SIZE(intel_parts),
-	.fixups = &intel_fixups,
 };
Signature · 6 lines
2.20.1


______________________________________________________
Linux MTD discussion mailing list
http://lists.infradead.org/mailman/listinfo/linux-mtd/
#13 lore raw

PATCH v7 6/7 mtd: spi-nor: atmel: fix unlock_all() for AT25FS010/040

In reply to Michael Walle

These flashes have some weird BP bits mapping which aren't supported in the current locking code. Just add a simple unlock op to unprotect the entire flash array which is needed for legacy behavior.

---
changes since v6:
- use spi_nor_write_sr_and_check() and log a debug message if writing fails

changes since v5:
- new patch

 drivers/mtd/spi-nor/atmel.c | 53 +++++++++++++++++++++++++++++++++++--
 drivers/mtd/spi-nor/core.c  |  2 +-
 drivers/mtd/spi-nor/core.h  |  1 +
 3 files changed, 53 insertions(+), 3 deletions(-)
drivers/mtd/spi-nor/atmel.c +51 -2
index 49d392c6c8bc..ee382a44bd0f 100644
@@ -8,10 +8,59 @@
 
 #include "core.h"
 
+/*
+ * The Atmel AT25FS010/AT25FS040 parts have some weird configuration for the
+ * block protection bits. We don't support them. But legacy behavior in linux
+ * is to unlock the whole flash array on startup. Therefore, we have to support
+ * exactly this operation.
+ */
+static int atmel_at25fs_lock(struct spi_nor *nor, loff_t ofs, uint64_t len)
+{
+	return -EOPNOTSUPP;
+}
+
+static int atmel_at25fs_unlock(struct spi_nor *nor, loff_t ofs, uint64_t len)
+{
+	int ret;
+
+	/* We only support unlocking the whole flash array */
+	if (ofs || len != nor->params->size)
+		return -EINVAL;
+
+	/* Write 0x00 to the status register to disable write protection */
+	ret = spi_nor_write_sr_and_check(nor, 0);
+	if (ret)
+		dev_dbg(nor->dev, "unable to clear BP bits, WP# asserted?\n");
+
+	return ret;
+}
+
+static int atmel_at25fs_is_locked(struct spi_nor *nor, loff_t ofs, uint64_t len)
+{
+	return -EOPNOTSUPP;
+}
+
+static const struct spi_nor_locking_ops atmel_at25fs_locking_ops = {
+	.lock = atmel_at25fs_lock,
+	.unlock = atmel_at25fs_unlock,
+	.is_locked = atmel_at25fs_is_locked,
+};
+
+static void atmel_at25fs_default_init(struct spi_nor *nor)
+{
+	nor->params->locking_ops = &atmel_at25fs_locking_ops;
+}
+
+static const struct spi_nor_fixups atmel_at25fs_fixups = {
+	.default_init = atmel_at25fs_default_init,
+};
+
 static const struct flash_info atmel_parts[] = {
 	/* Atmel -- some are (confusingly) marketed as "DataFlash" */
-	{ "at25fs010",  INFO(0x1f6601, 0, 32 * 1024,   4, SECT_4K | SPI_NOR_HAS_LOCK) },
-	{ "at25fs040",  INFO(0x1f6604, 0, 64 * 1024,   8, SECT_4K | SPI_NOR_HAS_LOCK) },
+	{ "at25fs010",  INFO(0x1f6601, 0, 32 * 1024,   4, SECT_4K | SPI_NOR_HAS_LOCK)
+		.fixups = &atmel_at25fs_fixups },
+	{ "at25fs040",  INFO(0x1f6604, 0, 64 * 1024,   8, SECT_4K | SPI_NOR_HAS_LOCK)
+		.fixups = &atmel_at25fs_fixups },
 
 	{ "at25df041a", INFO(0x1f4401, 0, 64 * 1024,   8, SECT_4K | SPI_NOR_HAS_LOCK) },
 	{ "at25df321",  INFO(0x1f4700, 0, 64 * 1024,  64, SECT_4K | SPI_NOR_HAS_LOCK) },
drivers/mtd/spi-nor/core.c +1 -1
index 013198abe929..6afcb99e9741 100644
@@ -1049,7 +1049,7 @@ static int spi_nor_write_16bit_cr_and_check(struct spi_nor *nor, u8 cr)
  *
  * Return: 0 on success, -errno otherwise.
  */
-static int spi_nor_write_sr_and_check(struct spi_nor *nor, u8 sr1)
+int spi_nor_write_sr_and_check(struct spi_nor *nor, u8 sr1)
 {
 	if (nor->flags & SNOR_F_HAS_16BIT_SR)
 		return spi_nor_write_16bit_sr_and_check(nor, sr1);
drivers/mtd/spi-nor/core.h +1 -0
index 0a775a7b5606..7780169d485b 100644
@@ -430,6 +430,7 @@ void spi_nor_unlock_and_unprep(struct spi_nor *nor);
 int spi_nor_sr1_bit6_quad_enable(struct spi_nor *nor);
 int spi_nor_sr2_bit1_quad_enable(struct spi_nor *nor);
 int spi_nor_sr2_bit7_quad_enable(struct spi_nor *nor);
+int spi_nor_write_sr_and_check(struct spi_nor *nor, u8 sr1);
 
 int spi_nor_xread_sr(struct spi_nor *nor, u8 *sr);
 ssize_t spi_nor_read_data(struct spi_nor *nor, loff_t from, size_t len,
Signature · 6 lines
2.20.1


______________________________________________________
Linux MTD discussion mailing list
http://lists.infradead.org/mailman/listinfo/linux-mtd/
Reviewed-by on v7 6/7
#14 lore raw

Re: [PATCH v7 6/7] mtd: spi-nor: atmel: fix unlock_all() for AT25FS010/040

Quoted 7 lines · Michael Walle

EXTERNAL EMAIL: Do not click links or open attachments unless you know the content is safe

These flashes have some weird BP bits mapping which aren't supported in the current locking code. Just add a simple unlock op to unprotect the entire flash array which is needed for legacy behavior.

With fixes tag added, one can add:

Quoted 107 lines

---
changes since v6:
- use spi_nor_write_sr_and_check() and log a debug message if writing fails

changes since v5:
- new patch

 drivers/mtd/spi-nor/atmel.c | 53 +++++++++++++++++++++++++++++++++++--
 drivers/mtd/spi-nor/core.c  |  2 +-
 drivers/mtd/spi-nor/core.h  |  1 +
 3 files changed, 53 insertions(+), 3 deletions(-)
drivers/mtd/spi-nor/atmel.c +51 -2
index 49d392c6c8bc..ee382a44bd0f 100644
@@ -8,10 +8,59 @@
 
 #include "core.h"
 
+/*
+ * The Atmel AT25FS010/AT25FS040 parts have some weird configuration for the
+ * block protection bits. We don't support them. But legacy behavior in linux
+ * is to unlock the whole flash array on startup. Therefore, we have to support
+ * exactly this operation.
+ */
+static int atmel_at25fs_lock(struct spi_nor *nor, loff_t ofs, uint64_t len)
+{
+       return -EOPNOTSUPP;
+}
+
+static int atmel_at25fs_unlock(struct spi_nor *nor, loff_t ofs, uint64_t len)
+{
+       int ret;
+
+       /* We only support unlocking the whole flash array */
+       if (ofs || len != nor->params->size)
+               return -EINVAL;
+
+       /* Write 0x00 to the status register to disable write protection */
+       ret = spi_nor_write_sr_and_check(nor, 0);
+       if (ret)
+               dev_dbg(nor->dev, "unable to clear BP bits, WP# asserted?\n");
+
+       return ret;
+}
+
+static int atmel_at25fs_is_locked(struct spi_nor *nor, loff_t ofs, uint64_t len)
+{
+       return -EOPNOTSUPP;
+}
+
+static const struct spi_nor_locking_ops atmel_at25fs_locking_ops = {
+       .lock = atmel_at25fs_lock,
+       .unlock = atmel_at25fs_unlock,
+       .is_locked = atmel_at25fs_is_locked,
+};
+
+static void atmel_at25fs_default_init(struct spi_nor *nor)
+{
+       nor->params->locking_ops = &atmel_at25fs_locking_ops;
+}
+
+static const struct spi_nor_fixups atmel_at25fs_fixups = {
+       .default_init = atmel_at25fs_default_init,
+};
+
 static const struct flash_info atmel_parts[] = {
        /* Atmel -- some are (confusingly) marketed as "DataFlash" */
-       { "at25fs010",  INFO(0x1f6601, 0, 32 * 1024,   4, SECT_4K | SPI_NOR_HAS_LOCK) },
-       { "at25fs040",  INFO(0x1f6604, 0, 64 * 1024,   8, SECT_4K | SPI_NOR_HAS_LOCK) },
+       { "at25fs010",  INFO(0x1f6601, 0, 32 * 1024,   4, SECT_4K | SPI_NOR_HAS_LOCK)
+               .fixups = &atmel_at25fs_fixups },
+       { "at25fs040",  INFO(0x1f6604, 0, 64 * 1024,   8, SECT_4K | SPI_NOR_HAS_LOCK)
+               .fixups = &atmel_at25fs_fixups },
 
        { "at25df041a", INFO(0x1f4401, 0, 64 * 1024,   8, SECT_4K | SPI_NOR_HAS_LOCK) },
        { "at25df321",  INFO(0x1f4700, 0, 64 * 1024,  64, SECT_4K | SPI_NOR_HAS_LOCK) },
drivers/mtd/spi-nor/core.c +1 -1
index 013198abe929..6afcb99e9741 100644
@@ -1049,7 +1049,7 @@ static int spi_nor_write_16bit_cr_and_check(struct spi_nor *nor, u8 cr)
  *
  * Return: 0 on success, -errno otherwise.
  */
-static int spi_nor_write_sr_and_check(struct spi_nor *nor, u8 sr1)
+int spi_nor_write_sr_and_check(struct spi_nor *nor, u8 sr1)
 {
        if (nor->flags & SNOR_F_HAS_16BIT_SR)
                return spi_nor_write_16bit_sr_and_check(nor, sr1);
drivers/mtd/spi-nor/core.h +1 -1
index 0a775a7b5606..7780169d485b 100644
@@ -430,6 +430,7 @@ void spi_nor_unlock_and_unprep(struct spi_nor *nor);
 int spi_nor_sr1_bit6_quad_enable(struct spi_nor *nor);
 int spi_nor_sr2_bit1_quad_enable(struct spi_nor *nor);
 int spi_nor_sr2_bit7_quad_enable(struct spi_nor *nor);
+int spi_nor_write_sr_and_check(struct spi_nor *nor, u8 sr1);
 
 int spi_nor_xread_sr(struct spi_nor *nor, u8 *sr);
 ssize_t spi_nor_read_data(struct spi_nor *nor, loff_t from, size_t len,
--

2.20.1

#15 lore raw

PATCH v7 7/7 mtd: spi-nor: keep lock bits if they are non-volatile

In reply to Michael Walle

Traditionally, linux unlocks the whole flash because there are legacy devices which has the write protections bits set by default at startup. If you actually want to use the flash protection bits, eg. because there is a read-only part for a bootloader, this automatic unlocking is harmful. If there is no hardware write protection in place (usually called WP#), a startup of the kernel just discards this protection.

I've gone through the datasheets of all the flashes (except the Intel ones where I could not find any datasheet nor reference) which supports the unlocking feature and looked how the sector protection was implemented. The currently supported flashes can be divided into the following two categories:
(1) block protection bits are non-volatile. Thus they keep their values at reset and power-cycle
(2) flashes where these bits are volatile. After reset or power-cycle, the whole memory array is protected.
(a) some devices needs a special "Global Unprotect" command, eg. the Atmel AT25DF041A.
(b) some devices require to clear the BPn bits in the status register.

Due to the reasons above, we do not want to clear the bits for flashes which belong to category (1). Fortunately for us, only Atmel flashes fall into category (2a). Implement the "Global Protect" and "Global Unprotect" commands for these. For (2b) we can use normal block protection locking scheme.

This patch adds a new flag to indicate the case (2). Only if we have such a flash we unlock the whole flash array. To be backwards compatible it also introduces a kernel configuration option which restores the complete legacy behavior ("Disable write protection on any flashes"). Hopefully, this will clean up "unlock the entire flash for legacy devices" once and for all.

For reference here are the actually commits which introduced the legacy behavior (and extended the behavior to other chip manufacturers):

commit f80e521c916cb ("mtd: m25p80: add support for the Intel/Numonyx {16,32,64}0S33B SPI flash chips") commit ea60658a08f8f ("mtd: m25p80: disable SST software protection bits by default") commit 7228982442365 ("[MTD] m25p80: fix bug - ATmel spi flash fails to be copied to")

Actually, this might also fix handling of the Atmel AT25DF flashes, because the original commit 7228982442365 ("[MTD] m25p80: fix bug - ATmel spi flash fails to be copied to") was writing a 0 to the status register, which is a "Global Unprotect". This might not be the case in the current code which only handles the block protection bits BP2, BP1 and BP0. Thus, it depends on the current contents of the status register if this unlock actually corresponds to a "Global Unprotect" command. In the worst case, the current code might leave the AT25DF flashes in a write protected state.

The commit 191f5c2ed4b6f ("mtd: spi-nor: use 16-bit WRR command when QE is set on spansion flashes") changed that behavior by just clearing BP2 to BP0 instead of writing a 0 to the status register.

Further, the commit 3e0930f109e76 ("mtd: spi-nor: Rework the disabling of block write protection") expanded the unlock_all() feature to ANY flash which supports locking.

---
changes since v6:
- fixed typos, small documentation changes
- changed _WP_ to _SWP_, "write protection" to "software write protection"
- use dev_dbg() instead of dev_err() to print message about WP pin

changes since v5:
- also set SRWD bit for the "Global Protect" command
- use spi_nor_write_sr() instead of spi_nor_write_sr_and_check() to send the "Global Protect" or "Global Unprotect" command
- mark ESMT F25L32QA as non-volatile as indicated in a newer datasheet revision
- rebased to latest tree

changes since v4:
- made atmel_global_protection_default_init() static, spotted by [email protected]

changes since v3:
- now defaulting to MTD_SPI_NOR_WP_DISABLE_ON_VOLATILE, suggested by Vignesh
- restored the original spi_nor_unlock_all(), instead add individual locking ops for the "Global Protect" scheme in atmel.c. This was tested partly with the AT25SL321 (for the test I added the fixups to this flash).
- renamed SPI_NOR_UNPROTECT to SPI_NOR_WP_IS_VOLATILE. Suggested by Vingesh, although I've renamed it to a more general "WP_IS_VOLATILE" because either the BP bits or the individual sector locks might be volatile.
- add mention of both block protection bits and "Global Unprotect" command in the Kconfig help text.

changes since v2:
- add Kconfig option to be able to retain legacy behavior
- rebased the patch due to the spi-nor rewrite
- dropped the Fixes: tag, it doens't make sense after the spi-nor rewrite
- mention commit 3e0930f109e76 which further modified the unlock behavior.

changes since v1:
- completely rewrote patch, the first version used a device tree flag

 drivers/mtd/spi-nor/Kconfig |  44 +++++++++++++
 drivers/mtd/spi-nor/atmel.c | 128 ++++++++++++++++++++++++++++++++++--
 drivers/mtd/spi-nor/core.c  |  23 ++++++-
 drivers/mtd/spi-nor/core.h  |   8 +++
 drivers/mtd/spi-nor/esmt.c  |   2 +-
 drivers/mtd/spi-nor/intel.c |   9 ++-
 drivers/mtd/spi-nor/sst.c   |  21 +++---
 7 files changed, 211 insertions(+), 24 deletions(-)
drivers/mtd/spi-nor/Kconfig +44 -0
index ffc4b380f2b1..d0f17919de3a 100644
@@ -24,6 +24,50 @@ config MTD_SPI_NOR_USE_4K_SECTORS
 	  Please note that some tools/drivers/filesystems may not work with
 	  4096 B erase size (e.g. UBIFS requires 15 KiB as a minimum).
 
+choice
+	prompt "Software write protection at boot"
+	default MTD_SPI_NOR_SWP_DISABLE_ON_VOLATILE
+
+config MTD_SPI_NOR_SWP_DISABLE
+	bool "Disable SWP on any flashes (legacy behavior)"
+	help
+	  This option disables the software write protection on any SPI
+	  flashes at boot-up.
+
+	  Depending on the flash chip this either clears the block protection
+	  bits or does a "Global Unprotect" command.
+
+	  Don't use this if you intent to use the software write protection
+	  of your SPI flash. This is only to keep backwards compatibility.
+
+config MTD_SPI_NOR_SWP_DISABLE_ON_VOLATILE
+	bool "Disable SWP on flashes w/ volatile protection bits"
+	help
+	  Some SPI flashes have volatile block protection bits, ie. after a
+	  power-up or a reset the flash is software write protected by
+	  default.
+
+	  This option disables the software write protection for these kind
+	  of flashes while keeping it enabled for any other SPI flashes
+	  which have non-volatile write protection bits.
+
+	  If the software write protection will be disabled depending on
+	  the flash either the block protection bits are cleared or a
+	  "Global Unprotect" command is issued.
+
+	  If you are unsure, select this option.
+
+config MTD_SPI_NOR_SWP_KEEP
+	bool "Keep software write protection as is"
+	help
+	  If you select this option the software write protection of any
+	  SPI flashes will not be changed. If your flash is software write
+	  protected or will be automatically software write protected after
+	  power-up you have to manually unlock it before you are able to
+	  write to it.
+
+endchoice
+
 source "drivers/mtd/spi-nor/controllers/Kconfig"
 
 endif # MTD_SPI_NOR
drivers/mtd/spi-nor/atmel.c +121 -7

151 lines not on this page · raw message

drivers/mtd/spi-nor/core.c +20 -3
index 6afcb99e9741..235acf3f4c43 100644
@@ -377,7 +377,7 @@ int spi_nor_write_disable(struct spi_nor *nor)
  *
  * Return: 0 on success, -errno otherwise.
  */
-static int spi_nor_read_sr(struct spi_nor *nor, u8 *sr)
+int spi_nor_read_sr(struct spi_nor *nor, u8 *sr)
 {
 	int ret;
 
@@ -861,7 +861,7 @@ int spi_nor_wait_till_ready(struct spi_nor *nor)
  *
  * Return: 0 on success, -errno otherwise.
  */
-static int spi_nor_write_sr(struct spi_nor *nor, const u8 *sr, size_t len)
+int spi_nor_write_sr(struct spi_nor *nor, const u8 *sr, size_t len)
 {
 	int ret;
 
@@ -3139,6 +3139,8 @@ static void spi_nor_try_unlock_all(struct spi_nor *nor)
 	if (!(nor->flags & SNOR_F_HAS_LOCK))
 		return;
 
+	dev_dbg(nor->dev, "Unprotecting entire flash array\n");
+
 	ret = spi_nor_unlock(&nor->mtd, 0, nor->params->size);
 	if (ret)
 		dev_dbg(nor->dev, "Failed to unlock the entire flash memory array\n");
@@ -3160,7 +3162,20 @@ static int spi_nor_init(struct spi_nor *nor)
 		return err;
 	}
 
-	spi_nor_try_unlock_all(nor);
+	/*
+	 * Some SPI NOR flashes are write protected by default after a power-on
+	 * reset cycle, in order to avoid inadvertent writes during power-up.
+	 * Backward compatibility imposes to unlock the entire flash memory
+	 * array at power-up by default. Depending on the kernel configuration
+	 * (1) do nothing, (2) always unlock the entire flash array or (3)
+	 * unlock the entire flash array only when the software write
+	 * protection bits are volatile. The latter is indicated by
+	 * SNOR_F_SWP_IS_VOLATILE.
+	 */
+	if (IS_ENABLED(CONFIG_MTD_SPI_NOR_SWP_DISABLE) ||
+	    (IS_ENABLED(CONFIG_MTD_SPI_NOR_SWP_DISABLE_ON_VOLATILE) &&
+	     nor->flags & SNOR_F_SWP_IS_VOLATILE))
+		spi_nor_try_unlock_all(nor);
 
 	if (nor->addr_width == 4 &&
 	    nor->read_proto != SNOR_PROTO_8_8_8_DTR &&
@@ -3459,6 +3474,8 @@ int spi_nor_scan(struct spi_nor *nor, const char *name,
 		nor->flags |= SNOR_F_NO_OP_CHIP_ERASE;
 	if (info->flags & USE_CLSR)
 		nor->flags |= SNOR_F_USE_CLSR;
+	if (info->flags & SPI_NOR_SWP_IS_VOLATILE)
+		nor->flags |= SNOR_F_SWP_IS_VOLATILE;
 
 	if (info->flags & SPI_NOR_4BIT_BP) {
 		nor->flags |= SNOR_F_HAS_4BIT_BP;
drivers/mtd/spi-nor/core.h +8 -0
index 7780169d485b..89acf499aecb 100644
@@ -28,6 +28,7 @@ enum spi_nor_option_flags {
 	SNOR_F_HAS_SR_BP3_BIT6  = BIT(13),
 	SNOR_F_IO_MODE_EN_VOLATILE = BIT(14),
 	SNOR_F_SOFT_RESET	= BIT(15),
+	SNOR_F_SWP_IS_VOLATILE	= BIT(16),
 };
 
 struct spi_nor_read_command {
@@ -329,6 +330,11 @@ struct flash_info {
 						 * available I/O mode via a
 						 * volatile bit.
 						 */
+#define SPI_NOR_SWP_IS_VOLATILE	BIT(22)	/*
+					 * Flash has volatile software write
+					 * protection bits. Usually these will
+					 * power-up in a write-protected state.
+					 */
 
 	/* Part specific fixup hooks. */
 	const struct spi_nor_fixups *fixups;
@@ -430,6 +436,8 @@ void spi_nor_unlock_and_unprep(struct spi_nor *nor);
 int spi_nor_sr1_bit6_quad_enable(struct spi_nor *nor);
 int spi_nor_sr2_bit1_quad_enable(struct spi_nor *nor);
 int spi_nor_sr2_bit7_quad_enable(struct spi_nor *nor);
+int spi_nor_read_sr(struct spi_nor *nor, u8 *sr);
+int spi_nor_write_sr(struct spi_nor *nor, const u8 *sr, size_t len);
 int spi_nor_write_sr_and_check(struct spi_nor *nor, u8 sr1);
 
 int spi_nor_xread_sr(struct spi_nor *nor, u8 *sr);
drivers/mtd/spi-nor/esmt.c +1 -1
index c93170008118..cfc9218c1053 100644
@@ -11,7 +11,7 @@
 static const struct flash_info esmt_parts[] = {
 	/* ESMT */
 	{ "f25l32pa", INFO(0x8c2016, 0, 64 * 1024, 64,
-			   SECT_4K | SPI_NOR_HAS_LOCK) },
+			   SECT_4K | SPI_NOR_HAS_LOCK | SPI_NOR_SWP_IS_VOLATILE) },
 	{ "f25l32qa", INFO(0x8c4116, 0, 64 * 1024, 64,
 			   SECT_4K | SPI_NOR_HAS_LOCK) },
 	{ "f25l64qa", INFO(0x8c4117, 0, 64 * 1024, 128,
drivers/mtd/spi-nor/intel.c +6 -3
index 6c31bef3fc60..8ece9cceb3cf 100644
@@ -10,9 +10,12 @@
 
 static const struct flash_info intel_parts[] = {
 	/* Intel/Numonyx -- xxxs33b */
-	{ "160s33b",  INFO(0x898911, 0, 64 * 1024,  32, SPI_NOR_HAS_LOCK) },
-	{ "320s33b",  INFO(0x898912, 0, 64 * 1024,  64, SPI_NOR_HAS_LOCK) },
-	{ "640s33b",  INFO(0x898913, 0, 64 * 1024, 128, SPI_NOR_HAS_LOCK) },
+	{ "160s33b",  INFO(0x898911, 0, 64 * 1024,  32,
+			   SPI_NOR_HAS_LOCK | SPI_NOR_SWP_IS_VOLATILE) },
+	{ "320s33b",  INFO(0x898912, 0, 64 * 1024,  64,
+			   SPI_NOR_HAS_LOCK | SPI_NOR_SWP_IS_VOLATILE) },
+	{ "640s33b",  INFO(0x898913, 0, 64 * 1024, 128,
+			   SPI_NOR_HAS_LOCK | SPI_NOR_SWP_IS_VOLATILE) },
 };
 
 const struct spi_nor_manufacturer spi_nor_intel = {
drivers/mtd/spi-nor/sst.c +11 -10
index 0d9d319f61e6..00e48da0744a 100644
@@ -11,27 +11,28 @@
 static const struct flash_info sst_parts[] = {
 	/* SST -- large erase sizes are "overlays", "sectors" are 4K */
 	{ "sst25vf040b", INFO(0xbf258d, 0, 64 * 1024,  8,
-			      SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK) },
+			      SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK | SPI_NOR_SWP_IS_VOLATILE) },
 	{ "sst25vf080b", INFO(0xbf258e, 0, 64 * 1024, 16,
-			      SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK) },
+			      SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK | SPI_NOR_SWP_IS_VOLATILE) },
 	{ "sst25vf016b", INFO(0xbf2541, 0, 64 * 1024, 32,
-			      SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK) },
+			      SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK | SPI_NOR_SWP_IS_VOLATILE) },
 	{ "sst25vf032b", INFO(0xbf254a, 0, 64 * 1024, 64,
-			      SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK) },
+			      SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK | SPI_NOR_SWP_IS_VOLATILE) },
 	{ "sst25vf064c", INFO(0xbf254b, 0, 64 * 1024, 128,
-			      SECT_4K | SPI_NOR_4BIT_BP | SPI_NOR_HAS_LOCK) },
+			      SECT_4K | SPI_NOR_4BIT_BP | SPI_NOR_HAS_LOCK |
+			      SPI_NOR_SWP_IS_VOLATILE) },
 	{ "sst25wf512",  INFO(0xbf2501, 0, 64 * 1024,  1,
-			      SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK) },
+			      SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK | SPI_NOR_SWP_IS_VOLATILE) },
 	{ "sst25wf010",  INFO(0xbf2502, 0, 64 * 1024,  2,
-			      SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK) },
+			      SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK | SPI_NOR_SWP_IS_VOLATILE) },
 	{ "sst25wf020",  INFO(0xbf2503, 0, 64 * 1024,  4,
-			      SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK) },
+			      SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK | SPI_NOR_SWP_IS_VOLATILE) },
 	{ "sst25wf020a", INFO(0x621612, 0, 64 * 1024,  4, SECT_4K | SPI_NOR_HAS_LOCK) },
 	{ "sst25wf040b", INFO(0x621613, 0, 64 * 1024,  8, SECT_4K | SPI_NOR_HAS_LOCK) },
 	{ "sst25wf040",  INFO(0xbf2504, 0, 64 * 1024,  8,
-			      SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK) },
+			      SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK | SPI_NOR_SWP_IS_VOLATILE) },
 	{ "sst25wf080",  INFO(0xbf2505, 0, 64 * 1024, 16,
-			      SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK) },
+			      SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK | SPI_NOR_SWP_IS_VOLATILE) },
 	{ "sst26wf016b", INFO(0xbf2651, 0, 64 * 1024, 32,
 			      SECT_4K | SPI_NOR_DUAL_READ |
 			      SPI_NOR_QUAD_READ) },
Signature · 6 lines
2.20.1


______________________________________________________
Linux MTD discussion mailing list
http://lists.infradead.org/mailman/listinfo/linux-mtd/
Reviewed-by on v7 7/7
#16 lore raw
Quoted 57 lines · Michael Walle

EXTERNAL EMAIL: Do not click links or open attachments unless you know the content is safe

Traditionally, linux unlocks the whole flash because there are legacy devices which has the write protections bits set by default at startup. If you actually want to use the flash protection bits, eg. because there is a read-only part for a bootloader, this automatic unlocking is harmful. If there is no hardware write protection in place (usually called WP#), a startup of the kernel just discards this protection.

I've gone through the datasheets of all the flashes (except the Intel ones where I could not find any datasheet nor reference) which supports the unlocking feature and looked how the sector protection was implemented. The currently supported flashes can be divided into the following two categories:
(1) block protection bits are non-volatile. Thus they keep their values at reset and power-cycle
(2) flashes where these bits are volatile. After reset or power-cycle, the whole memory array is protected.
(a) some devices needs a special "Global Unprotect" command, eg. the Atmel AT25DF041A.
(b) some devices require to clear the BPn bits in the status register.

Due to the reasons above, we do not want to clear the bits for flashes which belong to category (1). Fortunately for us, only Atmel flashes fall into category (2a). Implement the "Global Protect" and "Global Unprotect" commands for these. For (2b) we can use normal block protection locking scheme.

This patch adds a new flag to indicate the case (2). Only if we have such a flash we unlock the whole flash array. To be backwards compatible it also introduces a kernel configuration option which restores the complete legacy behavior ("Disable write protection on any flashes"). Hopefully, this will clean up "unlock the entire flash for legacy devices" once and for all.

For reference here are the actually commits which introduced the legacy behavior (and extended the behavior to other chip manufacturers):

commit f80e521c916cb ("mtd: m25p80: add support for the Intel/Numonyx {16,32,64}0S33B SPI flash chips") commit ea60658a08f8f ("mtd: m25p80: disable SST software protection bits by default") commit 7228982442365 ("[MTD] m25p80: fix bug - ATmel spi flash fails to be copied to")

Actually, this might also fix handling of the Atmel AT25DF flashes, because the original commit 7228982442365 ("[MTD] m25p80: fix bug - ATmel spi flash fails to be copied to") was writing a 0 to the status register, which is a "Global Unprotect". This might not be the case in the current code which only handles the block protection bits BP2, BP1 and BP0. Thus, it depends on the current contents of the status register if this unlock actually corresponds to a "Global Unprotect" command. In the worst case, the current code might leave the AT25DF flashes in a write protected state.

The commit 191f5c2ed4b6f ("mtd: spi-nor: use 16-bit WRR command when QE is set on spansion flashes") changed that behavior by just clearing BP2 to BP0 instead of writing a 0 to the status register.

Quoted 5 lines

Further, the commit 3e0930f109e76 ("mtd: spi-nor: Rework the disabling of block write protection") expanded the unlock_all() feature to ANY flash which supports locking.

nice work, thanks!

Quoted 436 lines

---
changes since v6:
- fixed typos, small documentation changes
- changed _WP_ to _SWP_, "write protection" to "software write protection"
- use dev_dbg() instead of dev_err() to print message about WP pin

changes since v5:
- also set SRWD bit for the "Global Protect" command
- use spi_nor_write_sr() instead of spi_nor_write_sr_and_check() to send the "Global Protect" or "Global Unprotect" command
- mark ESMT F25L32QA as non-volatile as indicated in a newer datasheet revision
- rebased to latest tree

changes since v4:
- made atmel_global_protection_default_init() static, spotted by [email protected]

changes since v3:
- now defaulting to MTD_SPI_NOR_WP_DISABLE_ON_VOLATILE, suggested by Vignesh
- restored the original spi_nor_unlock_all(), instead add individual locking ops for the "Global Protect" scheme in atmel.c. This was tested partly with the AT25SL321 (for the test I added the fixups to this flash).
- renamed SPI_NOR_UNPROTECT to SPI_NOR_WP_IS_VOLATILE. Suggested by Vingesh, although I've renamed it to a more general "WP_IS_VOLATILE" because either the BP bits or the individual sector locks might be volatile.
- add mention of both block protection bits and "Global Unprotect" command in the Kconfig help text.

changes since v2:
- add Kconfig option to be able to retain legacy behavior
- rebased the patch due to the spi-nor rewrite
- dropped the Fixes: tag, it doens't make sense after the spi-nor rewrite
- mention commit 3e0930f109e76 which further modified the unlock behavior.

changes since v1:
- completely rewrote patch, the first version used a device tree flag

 drivers/mtd/spi-nor/Kconfig |  44 +++++++++++++
 drivers/mtd/spi-nor/atmel.c | 128 ++++++++++++++++++++++++++++++++++--
 drivers/mtd/spi-nor/core.c  |  23 ++++++-
 drivers/mtd/spi-nor/core.h  |   8 +++
 drivers/mtd/spi-nor/esmt.c  |   2 +-
 drivers/mtd/spi-nor/intel.c |   9 ++-
 drivers/mtd/spi-nor/sst.c   |  21 +++---
 7 files changed, 211 insertions(+), 24 deletions(-)
drivers/mtd/spi-nor/Kconfig +44 -0
index ffc4b380f2b1..d0f17919de3a 100644
@@ -24,6 +24,50 @@ config MTD_SPI_NOR_USE_4K_SECTORS
          Please note that some tools/drivers/filesystems may not work with
          4096 B erase size (e.g. UBIFS requires 15 KiB as a minimum).
 
+choice
+       prompt "Software write protection at boot"
+       default MTD_SPI_NOR_SWP_DISABLE_ON_VOLATILE
+
+config MTD_SPI_NOR_SWP_DISABLE
+       bool "Disable SWP on any flashes (legacy behavior)"
+       help
+         This option disables the software write protection on any SPI
+         flashes at boot-up.
+
+         Depending on the flash chip this either clears the block protection
+         bits or does a "Global Unprotect" command.
+
+         Don't use this if you intent to use the software write protection
+         of your SPI flash. This is only to keep backwards compatibility.
+
+config MTD_SPI_NOR_SWP_DISABLE_ON_VOLATILE
+       bool "Disable SWP on flashes w/ volatile protection bits"
+       help
+         Some SPI flashes have volatile block protection bits, ie. after a
+         power-up or a reset the flash is software write protected by
+         default.
+
+         This option disables the software write protection for these kind
+         of flashes while keeping it enabled for any other SPI flashes
+         which have non-volatile write protection bits.
+
+         If the software write protection will be disabled depending on
+         the flash either the block protection bits are cleared or a
+         "Global Unprotect" command is issued.
+
+         If you are unsure, select this option.
+
+config MTD_SPI_NOR_SWP_KEEP
+       bool "Keep software write protection as is"
+       help
+         If you select this option the software write protection of any
+         SPI flashes will not be changed. If your flash is software write
+         protected or will be automatically software write protected after
+         power-up you have to manually unlock it before you are able to
+         write to it.
+
+endchoice
+
 source "drivers/mtd/spi-nor/controllers/Kconfig"
 
 endif # MTD_SPI_NOR
drivers/mtd/spi-nor/atmel.c +121 -7
index ee382a44bd0f..2000babc6a81 100644
@@ -8,6 +8,8 @@
 
 #include "core.h"
 
+#define ATMEL_SR_GLOBAL_PROTECT_MASK GENMASK(5, 2)
+
 /*
  * The Atmel AT25FS010/AT25FS040 parts have some weird configuration for the
  * block protection bits. We don't support them. But legacy behavior in linux
@@ -55,6 +57,104 @@ static const struct spi_nor_fixups atmel_at25fs_fixups = {
        .default_init = atmel_at25fs_default_init,
 };
 
+/**
+ * atmel_set_global_protection - Do a Global Protect or Unprotect command
+ * @nor:       pointer to 'struct spi_nor'
+ * @ofs:       offset in bytes
+ * @len:       len in bytes
+ * @is_protect:        if true do a Global Protect otherwise it is a Global Unprotect
+ *
+ * Return: 0 on success, -error otherwise.
+ */
+static int atmel_set_global_protection(struct spi_nor *nor, loff_t ofs,
+                                      uint64_t len, bool is_protect)
+{
+       int ret;
+       u8 sr;
+
+       /* We only support locking the whole flash array */
+       if (ofs || len != nor->params->size)
+               return -EINVAL;
+
+       ret = spi_nor_read_sr(nor, nor->bouncebuf);
+       if (ret)
+               return ret;
+
+       sr = nor->bouncebuf[0];
+
+       /* SRWD bit needs to be cleared, otherwise the protection doesn't change */
+       if (sr & SR_SRWD) {
+               sr &= ~SR_SRWD;
+               ret = spi_nor_write_sr_and_check(nor, sr);
+               if (ret) {
+                       dev_dbg(nor->dev, "unable to clear SRWD bit, WP# asserted?\n");
+                       return ret;
+               }
+       }
+
+       if (is_protect) {
+               sr |= ATMEL_SR_GLOBAL_PROTECT_MASK;
+               /*
+                * Set the SRWD bit again as soon as we are protecting
+                * anything. This will ensure that the WP# pin is working
+                * correctly. By doing this we also behave the same as
+                * spi_nor_sr_lock(), which sets SRWD if any block protection
+                * is active.
+                */
+               sr |= SR_SRWD;
+       } else {
+               sr &= ~ATMEL_SR_GLOBAL_PROTECT_MASK;
+       }
+
+       nor->bouncebuf[0] = sr;
+
+       /*
+        * We cannot use the spi_nor_write_sr_and_check() because this command
+        * isn't really setting any bits, instead it is an pseudo command for
+        * "Global Unprotect" or "Global Protect"
+        */
+       return spi_nor_write_sr(nor, nor->bouncebuf, 1);
+}
+
+static int atmel_global_protect(struct spi_nor *nor, loff_t ofs, uint64_t len)
+{
+       return atmel_set_global_protection(nor, ofs, len, true);
+}
+
+static int atmel_global_unprotect(struct spi_nor *nor, loff_t ofs, uint64_t len)
+{
+       return atmel_set_global_protection(nor, ofs, len, false);
+}
+
+static int atmel_is_global_protected(struct spi_nor *nor, loff_t ofs, uint64_t len)
+{
+       int ret;
+
+       if (ofs >= nor->params->size || (ofs + len) > nor->params->size)
+               return -EINVAL;
+
+       ret = spi_nor_read_sr(nor, nor->bouncebuf);
+       if (ret)
+               return ret;
+
+       return ((nor->bouncebuf[0] & ATMEL_SR_GLOBAL_PROTECT_MASK) == ATMEL_SR_GLOBAL_PROTECT_MASK);
+}
+
+static const struct spi_nor_locking_ops atmel_global_protection_ops = {
+       .lock = atmel_global_protect,
+       .unlock = atmel_global_unprotect,
+       .is_locked = atmel_is_global_protected,
+};
+
+static void atmel_global_protection_default_init(struct spi_nor *nor)
+{
+       nor->params->locking_ops = &atmel_global_protection_ops;
+}
+
+static const struct spi_nor_fixups atmel_global_protection_fixups = {
+       .default_init = atmel_global_protection_default_init,
+};
+
 static const struct flash_info atmel_parts[] = {
        /* Atmel -- some are (confusingly) marketed as "DataFlash" */
        { "at25fs010",  INFO(0x1f6601, 0, 32 * 1024,   4, SECT_4K | SPI_NOR_HAS_LOCK)
@@ -62,18 +162,32 @@ static const struct flash_info atmel_parts[] = {
        { "at25fs040",  INFO(0x1f6604, 0, 64 * 1024,   8, SECT_4K | SPI_NOR_HAS_LOCK)
                .fixups = &atmel_at25fs_fixups },
 
-       { "at25df041a", INFO(0x1f4401, 0, 64 * 1024,   8, SECT_4K | SPI_NOR_HAS_LOCK) },
-       { "at25df321",  INFO(0x1f4700, 0, 64 * 1024,  64, SECT_4K | SPI_NOR_HAS_LOCK) },
-       { "at25df321a", INFO(0x1f4701, 0, 64 * 1024,  64, SECT_4K | SPI_NOR_HAS_LOCK) },
-       { "at25df641",  INFO(0x1f4800, 0, 64 * 1024, 128, SECT_4K | SPI_NOR_HAS_LOCK) },
+       { "at25df041a", INFO(0x1f4401, 0, 64 * 1024,   8,
+                            SECT_4K | SPI_NOR_HAS_LOCK | SPI_NOR_SWP_IS_VOLATILE)
+                       .fixups = &atmel_global_protection_fixups },
+       { "at25df321",  INFO(0x1f4700, 0, 64 * 1024,  64,
+                            SECT_4K | SPI_NOR_HAS_LOCK | SPI_NOR_SWP_IS_VOLATILE)
+                       .fixups = &atmel_global_protection_fixups },
+       { "at25df321a", INFO(0x1f4701, 0, 64 * 1024,  64,
+                            SECT_4K | SPI_NOR_HAS_LOCK | SPI_NOR_SWP_IS_VOLATILE)
+                       .fixups = &atmel_global_protection_fixups },
+       { "at25df641",  INFO(0x1f4800, 0, 64 * 1024, 128,
+                            SECT_4K | SPI_NOR_HAS_LOCK | SPI_NOR_SWP_IS_VOLATILE)
+                       .fixups = &atmel_global_protection_fixups },
 
        { "at25sl321",  INFO(0x1f4216, 0, 64 * 1024, 64,
                             SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
 
        { "at26f004",   INFO(0x1f0400, 0, 64 * 1024,  8, SECT_4K) },
-       { "at26df081a", INFO(0x1f4501, 0, 64 * 1024, 16, SECT_4K | SPI_NOR_HAS_LOCK) },
-       { "at26df161a", INFO(0x1f4601, 0, 64 * 1024, 32, SECT_4K | SPI_NOR_HAS_LOCK) },
-       { "at26df321",  INFO(0x1f4700, 0, 64 * 1024, 64, SECT_4K | SPI_NOR_HAS_LOCK) },
+       { "at26df081a", INFO(0x1f4501, 0, 64 * 1024, 16,
+                            SECT_4K | SPI_NOR_HAS_LOCK | SPI_NOR_SWP_IS_VOLATILE)
+                       .fixups = &atmel_global_protection_fixups },
+       { "at26df161a", INFO(0x1f4601, 0, 64 * 1024, 32,
+                            SECT_4K | SPI_NOR_HAS_LOCK | SPI_NOR_SWP_IS_VOLATILE)
+                       .fixups = &atmel_global_protection_fixups },
+       { "at26df321",  INFO(0x1f4700, 0, 64 * 1024, 64,
+                            SECT_4K | SPI_NOR_HAS_LOCK | SPI_NOR_SWP_IS_VOLATILE)
+                       .fixups = &atmel_global_protection_fixups },
 
        { "at45db081d", INFO(0x1f2500, 0, 64 * 1024, 16, SECT_4K) },
 };
drivers/mtd/spi-nor/core.c +20 -3
index 6afcb99e9741..235acf3f4c43 100644
@@ -377,7 +377,7 @@ int spi_nor_write_disable(struct spi_nor *nor)
  *
  * Return: 0 on success, -errno otherwise.
  */
-static int spi_nor_read_sr(struct spi_nor *nor, u8 *sr)
+int spi_nor_read_sr(struct spi_nor *nor, u8 *sr)
 {
        int ret;
 
@@ -861,7 +861,7 @@ int spi_nor_wait_till_ready(struct spi_nor *nor)
  *
  * Return: 0 on success, -errno otherwise.
  */
-static int spi_nor_write_sr(struct spi_nor *nor, const u8 *sr, size_t len)
+int spi_nor_write_sr(struct spi_nor *nor, const u8 *sr, size_t len)
 {
        int ret;
 
@@ -3139,6 +3139,8 @@ static void spi_nor_try_unlock_all(struct spi_nor *nor)
        if (!(nor->flags & SNOR_F_HAS_LOCK))
                return;
 
+       dev_dbg(nor->dev, "Unprotecting entire flash array\n");
+
        ret = spi_nor_unlock(&nor->mtd, 0, nor->params->size);
        if (ret)
                dev_dbg(nor->dev, "Failed to unlock the entire flash memory array\n");
@@ -3160,7 +3162,20 @@ static int spi_nor_init(struct spi_nor *nor)
                return err;
        }
 
-       spi_nor_try_unlock_all(nor);
+       /*
+        * Some SPI NOR flashes are write protected by default after a power-on
+        * reset cycle, in order to avoid inadvertent writes during power-up.
+        * Backward compatibility imposes to unlock the entire flash memory
+        * array at power-up by default. Depending on the kernel configuration
+        * (1) do nothing, (2) always unlock the entire flash array or (3)
+        * unlock the entire flash array only when the software write
+        * protection bits are volatile. The latter is indicated by
+        * SNOR_F_SWP_IS_VOLATILE.
+        */
+       if (IS_ENABLED(CONFIG_MTD_SPI_NOR_SWP_DISABLE) ||
+           (IS_ENABLED(CONFIG_MTD_SPI_NOR_SWP_DISABLE_ON_VOLATILE) &&
+            nor->flags & SNOR_F_SWP_IS_VOLATILE))
+               spi_nor_try_unlock_all(nor);
 
        if (nor->addr_width == 4 &&
            nor->read_proto != SNOR_PROTO_8_8_8_DTR &&
@@ -3459,6 +3474,8 @@ int spi_nor_scan(struct spi_nor *nor, const char *name,
                nor->flags |= SNOR_F_NO_OP_CHIP_ERASE;
        if (info->flags & USE_CLSR)
                nor->flags |= SNOR_F_USE_CLSR;
+       if (info->flags & SPI_NOR_SWP_IS_VOLATILE)
+               nor->flags |= SNOR_F_SWP_IS_VOLATILE;
 
        if (info->flags & SPI_NOR_4BIT_BP) {
                nor->flags |= SNOR_F_HAS_4BIT_BP;
drivers/mtd/spi-nor/core.h +8 -0
index 7780169d485b..89acf499aecb 100644
@@ -28,6 +28,7 @@ enum spi_nor_option_flags {
        SNOR_F_HAS_SR_BP3_BIT6  = BIT(13),
        SNOR_F_IO_MODE_EN_VOLATILE = BIT(14),
        SNOR_F_SOFT_RESET       = BIT(15),
+       SNOR_F_SWP_IS_VOLATILE  = BIT(16),
 };
 
 struct spi_nor_read_command {
@@ -329,6 +330,11 @@ struct flash_info {
                                                 * available I/O mode via a
                                                 * volatile bit.
                                                 */
+#define SPI_NOR_SWP_IS_VOLATILE        BIT(22) /*
+                                        * Flash has volatile software write
+                                        * protection bits. Usually these will
+                                        * power-up in a write-protected state.
+                                        */
 
        /* Part specific fixup hooks. */
        const struct spi_nor_fixups *fixups;
@@ -430,6 +436,8 @@ void spi_nor_unlock_and_unprep(struct spi_nor *nor);
 int spi_nor_sr1_bit6_quad_enable(struct spi_nor *nor);
 int spi_nor_sr2_bit1_quad_enable(struct spi_nor *nor);
 int spi_nor_sr2_bit7_quad_enable(struct spi_nor *nor);
+int spi_nor_read_sr(struct spi_nor *nor, u8 *sr);
+int spi_nor_write_sr(struct spi_nor *nor, const u8 *sr, size_t len);
 int spi_nor_write_sr_and_check(struct spi_nor *nor, u8 sr1);
 
 int spi_nor_xread_sr(struct spi_nor *nor, u8 *sr);
drivers/mtd/spi-nor/esmt.c +1 -1
index c93170008118..cfc9218c1053 100644
@@ -11,7 +11,7 @@
 static const struct flash_info esmt_parts[] = {
        /* ESMT */
        { "f25l32pa", INFO(0x8c2016, 0, 64 * 1024, 64,
-                          SECT_4K | SPI_NOR_HAS_LOCK) },
+                          SECT_4K | SPI_NOR_HAS_LOCK | SPI_NOR_SWP_IS_VOLATILE) },
        { "f25l32qa", INFO(0x8c4116, 0, 64 * 1024, 64,
                           SECT_4K | SPI_NOR_HAS_LOCK) },
        { "f25l64qa", INFO(0x8c4117, 0, 64 * 1024, 128,
drivers/mtd/spi-nor/intel.c +6 -3
index 6c31bef3fc60..8ece9cceb3cf 100644
@@ -10,9 +10,12 @@
 
 static const struct flash_info intel_parts[] = {
        /* Intel/Numonyx -- xxxs33b */
-       { "160s33b",  INFO(0x898911, 0, 64 * 1024,  32, SPI_NOR_HAS_LOCK) },
-       { "320s33b",  INFO(0x898912, 0, 64 * 1024,  64, SPI_NOR_HAS_LOCK) },
-       { "640s33b",  INFO(0x898913, 0, 64 * 1024, 128, SPI_NOR_HAS_LOCK) },
+       { "160s33b",  INFO(0x898911, 0, 64 * 1024,  32,
+                          SPI_NOR_HAS_LOCK | SPI_NOR_SWP_IS_VOLATILE) },
+       { "320s33b",  INFO(0x898912, 0, 64 * 1024,  64,
+                          SPI_NOR_HAS_LOCK | SPI_NOR_SWP_IS_VOLATILE) },
+       { "640s33b",  INFO(0x898913, 0, 64 * 1024, 128,
+                          SPI_NOR_HAS_LOCK | SPI_NOR_SWP_IS_VOLATILE) },
 };
 
 const struct spi_nor_manufacturer spi_nor_intel = {
drivers/mtd/spi-nor/sst.c +11 -11
index 0d9d319f61e6..00e48da0744a 100644
@@ -11,27 +11,28 @@
 static const struct flash_info sst_parts[] = {
        /* SST -- large erase sizes are "overlays", "sectors" are 4K */
        { "sst25vf040b", INFO(0xbf258d, 0, 64 * 1024,  8,
-                             SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK) },
+                             SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK | SPI_NOR_SWP_IS_VOLATILE) },
        { "sst25vf080b", INFO(0xbf258e, 0, 64 * 1024, 16,
-                             SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK) },
+                             SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK | SPI_NOR_SWP_IS_VOLATILE) },
        { "sst25vf016b", INFO(0xbf2541, 0, 64 * 1024, 32,
-                             SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK) },
+                             SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK | SPI_NOR_SWP_IS_VOLATILE) },
        { "sst25vf032b", INFO(0xbf254a, 0, 64 * 1024, 64,
-                             SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK) },
+                             SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK | SPI_NOR_SWP_IS_VOLATILE) },
        { "sst25vf064c", INFO(0xbf254b, 0, 64 * 1024, 128,
-                             SECT_4K | SPI_NOR_4BIT_BP | SPI_NOR_HAS_LOCK) },
+                             SECT_4K | SPI_NOR_4BIT_BP | SPI_NOR_HAS_LOCK |
+                             SPI_NOR_SWP_IS_VOLATILE) },
        { "sst25wf512",  INFO(0xbf2501, 0, 64 * 1024,  1,
-                             SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK) },
+                             SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK | SPI_NOR_SWP_IS_VOLATILE) },
        { "sst25wf010",  INFO(0xbf2502, 0, 64 * 1024,  2,
-                             SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK) },
+                             SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK | SPI_NOR_SWP_IS_VOLATILE) },
        { "sst25wf020",  INFO(0xbf2503, 0, 64 * 1024,  4,
-                             SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK) },
+                             SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK | SPI_NOR_SWP_IS_VOLATILE) },
        { "sst25wf020a", INFO(0x621612, 0, 64 * 1024,  4, SECT_4K | SPI_NOR_HAS_LOCK) },
        { "sst25wf040b", INFO(0x621613, 0, 64 * 1024,  8, SECT_4K | SPI_NOR_HAS_LOCK) },
        { "sst25wf040",  INFO(0xbf2504, 0, 64 * 1024,  8,
-                             SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK) },
+                             SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK | SPI_NOR_SWP_IS_VOLATILE) },
        { "sst25wf080",  INFO(0xbf2505, 0, 64 * 1024, 16,
-                             SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK) },
+                             SECT_4K | SST_WRITE | SPI_NOR_HAS_LOCK | SPI_NOR_SWP_IS_VOLATILE) },
        { "sst26wf016b", INFO(0xbf2651, 0, 64 * 1024, 32,
                              SECT_4K | SPI_NOR_DUAL_READ |
                              SPI_NOR_QUAD_READ) },
--
Quoted 2 lines

2.20.1

______________________________________________________
Linux MTD discussion mailing list
http://lists.infradead.org/mailman/listinfo/linux-mtd/