mtd: spi-nor: implement OTP erase for Winbond and similar flashes
Subsystems (2)
PATCH v2 1/1 mtd: spi-nor: implement OTP erase for Winbond and similar flashes
Winbond flashes with OTP support provide a command to erase the OTP data. This might come in handy during development.
This was tested with a Winbond W25Q32JW on a LS1028A SoC with the NXP FSPI controller.
---
Changes since v1:
- fixed kernel doc
There is also a patch for mtd-utils to add a small tool to issue the erase:
https://lore.kernel.org/linux-mtd/[email protected]/
drivers/mtd/spi-nor/core.c | 4 +- drivers/mtd/spi-nor/core.h | 4 ++ drivers/mtd/spi-nor/otp.c | 73 ++++++++++++++++++++++++++++++++++- drivers/mtd/spi-nor/winbond.c | 1 + 4 files changed, 78 insertions(+), 4 deletions(-)
drivers/mtd/spi-nor/core.c +2 -2
@@ -166,8 +166,8 @@ static int spi_nor_controller_ops_read_reg(struct spi_nor *nor, u8 opcode,return nor->controller_ops->read_reg (nor, opcode, buf, len); } -static int spi_nor_controller_ops_write_reg (struct spi_nor *nor,u8 opcode, -const u8 *buf,size_t len) +int spi_nor_controller_ops_write_reg (struct spi_nor *nor,u8 opcode, +const u8 *buf,size_t len) {if (spi_nor_protocol_is_dtr (nor->reg_proto))return -EOPNOTSUPP ;
drivers/mtd/spi-nor/core.h +4 -0
@@ -214,6 +214,7 @@ struct spi_nor_otp_ops {int (*write)(struct spi_nor *nor,loff_t addr,size_t len,const u8 *buf);int (*lock)(struct spi_nor *nor,unsigned int region); +int (*erase)(struct spi_nor *nor,loff_t addr);int (*is_locked)(struct spi_nor *nor,unsigned int region); };
@@ -481,6 +482,8 @@ extern const struct spi_nor_manufacturer spi_nor_xmc;void spi_nor_spimem_setup_op (const struct spi_nor *nor,struct spi_mem_op *op,const enum spi_nor_protocol proto); +int spi_nor_controller_ops_write_reg (struct spi_nor *nor,u8 opcode, +const u8 *buf,size_t len);int spi_nor_write_enable (struct spi_nor *nor);int spi_nor_write_disable (struct spi_nor *nor);int spi_nor_set_4byte_addr_mode (struct spi_nor *nor,bool enable);
@@ -507,6 +510,7 @@ ssize_t spi_nor_write_data(struct spi_nor *nor, loff_t to, size_t len,int spi_nor_otp_read_secr (struct spi_nor *nor,loff_t addr,size_t len,u8 *buf);int spi_nor_otp_write_secr (struct spi_nor *nor,loff_t addr,size_t len,const u8 *buf); +int spi_nor_otp_erase_secr (struct spi_nor *nor,loff_t addr);int spi_nor_otp_lock_sr2 (struct spi_nor *nor,unsigned int region);int spi_nor_otp_is_locked_sr2 (struct spi_nor *nor,unsigned int region);
drivers/mtd/spi-nor/otp.c +71 -2
112 lines not on this page · raw message
drivers/mtd/spi-nor/winbond.c +1 -0
@@ -139,6 +139,7 @@ static int winbond_set_4byte_addr_mode(struct spi_nor *nor, bool enable)static const struct spi_nor_otp_ops winbond_otp_ops = { .read = spi_nor_otp_read_secr, .write = spi_nor_otp_write_secr, + .erase = spi_nor_otp_erase_secr, .lock = spi_nor_otp_lock_sr2, .is_locked = spi_nor_otp_is_locked_sr2, };
Signature · 1 line
2.20.1
Hi Michael,
Quoted 2 lines · Michael Walle
Winbond flashes with OTP support provide a command to erase the OTP data. This might come in handy during development.
I am not very familiar with the OTP feature. It is supposed to be "One Time Programmable". So does erasing the OTP area make it programmable again? Or it just erases the data and then the OTP region will forever be 0xff?
Because if you can erase and reprogram it, how is it OTP at all?
Quoted 3 lines
This was tested with a Winbond W25Q32JW on a LS1028A SoC with the NXP FSPI controller.
I got the datasheet for this flash from
https://www.elinux.org/images/f/f5/Winbond-w25q32.pdf but it doesn't seem to mention the erase OTP command (0x44).
Quoted 36 lines
Signed-off-by Michael Walle <[email protected]>---
Changes since v1:
- fixed kernel docThere is also a patch for mtd-utils to add a small tool to issue the erase:
https://lore.kernel.org/linux-mtd/[email protected]/drivers/mtd/spi-nor/core.c | 4 +- drivers/mtd/spi-nor/core.h | 4 ++ drivers/mtd/spi-nor/otp.c | 73 ++++++++++++++++++++++++++++++++++- drivers/mtd/spi-nor/winbond.c | 1 + 4 files changed, 78 insertions(+), 4 deletions(-)drivers/mtd/spi-nor/core.c +2
-2@@ -166,8 +166,8 @@ static int spi_nor_controller_ops_read_reg(struct spi_nor *nor, u8 opcode,return nor->controller_ops->read_reg (nor, opcode, buf, len); } -static int spi_nor_controller_ops_write_reg (struct spi_nor *nor,u8 opcode, -const u8 *buf,size_t len) +int spi_nor_controller_ops_write_reg (struct spi_nor *nor,u8 opcode, +const u8 *buf,size_t len) {if (spi_nor_protocol_is_dtr (nor->reg_proto))return -EOPNOTSUPP ;drivers/mtd/spi-nor/core.h +0
-0
drivers/mtd/spi-nor/core.h struct spi_nor_otp_ops { · line 217
Quoted 4 lines
drivers/mtd/spi-nor/core.h +1
-0@@ -214,6 +214,7 @@ struct spi_nor_otp_ops {int (*write)(struct spi_nor *nor,loff_t addr,size_t len,const u8 *buf);int (*lock)(struct spi_nor *nor,unsigned int region); +int (*erase)(struct spi_nor *nor,loff_t addr);
No doc update above?
Quoted 33 lines
drivers/mtd/spi-nor/core.h +3
-0int (*is_locked)(struct spi_nor *nor,unsigned int region); };@@ -481,6 +482,8 @@ extern const struct spi_nor_manufacturer spi_nor_xmc;void spi_nor_spimem_setup_op (const struct spi_nor *nor,struct spi_mem_op *op,const enum spi_nor_protocol proto); +int spi_nor_controller_ops_write_reg (struct spi_nor *nor,u8 opcode, +const u8 *buf,size_t len);int spi_nor_write_enable (struct spi_nor *nor);int spi_nor_write_disable (struct spi_nor *nor);int spi_nor_set_4byte_addr_mode (struct spi_nor *nor,bool enable);@@ -507,6 +510,7 @@ ssize_t spi_nor_write_data(struct spi_nor *nor, loff_t to, size_t len,int spi_nor_otp_read_secr (struct spi_nor *nor,loff_t addr,size_t len,u8 *buf);int spi_nor_otp_write_secr (struct spi_nor *nor,loff_t addr,size_t len,const u8 *buf); +int spi_nor_otp_erase_secr (struct spi_nor *nor,loff_t addr);int spi_nor_otp_lock_sr2 (struct spi_nor *nor,unsigned int region);int spi_nor_otp_is_locked_sr2 (struct spi_nor *nor,unsigned int region);drivers/mtd/spi-nor/otp.c +1
-0@@ -8,6 +8,7 @@#include <linux/log2.h> #include <linux/mtd/mtd.h> #include <linux/mtd/spi-nor.h> +#include <linux/spi/spi-mem.h> #include "core.h"
drivers/mtd/spi-nor/otp.c int spi_nor_otp_write_secr(struct spi_nor *nor, loff_t addr, size_t len, · line 116
Quoted 5 lines
drivers/mtd/spi-nor/otp.c +2
-0@@ -111,6 +112,48 @@ int spi_nor_otp_write_secr(struct spi_nor *nor, loff_t addr, size_t len,return ret ?: written; } +/** +* spi_nor_otp_erase_secr() - erase one OTP region
Nitpick: The function is called erase_secr() but the comment says erase region. Please use consistent wording.
Quoted 10 lines
drivers/mtd/spi-nor/otp.c +10
-0+* @nor: pointer to 'struct spi_nor' +* @addr: offset of the OTP region to be erased +* +* Erase one OTP region by using the SPINOR_OP_ESECR commands. This method is +* used on GigaDevice and Winbond flashes. +* +* Return: 0 on success, -errno otherwise +*/ +int spi_nor_otp_erase_secr (struct spi_nor *nor,loff_t addr) +{
drivers/mtd/spi-nor/otp.c int spi_nor_otp_write_secr(struct spi_nor *nor, loff_t addr, size_t len, · line 136
Quoted 10 lines
drivers/mtd/spi-nor/otp.c +10
-0+int ret; + + ret =spi_nor_write_enable (nor); +if (ret) +return ret; + +if (nor->spimem) { +struct spi_mem_op op = + SPI_MEM_OP(SPI_MEM_OP_CMD(SPINOR_OP_ESECR, 0), + SPI_MEM_OP_ADDR(3, addr, 0),
Only 3 address bytes needed? Can the OTP region ever require 4 byte addressing? For example, say the flash is switched to 4 byte addressing for the main region. Would it still expect 3 byte addressing for OTP ops?
drivers/mtd/spi-nor/otp.c int spi_nor_otp_write_secr(struct spi_nor *nor, loff_t addr, size_t len, · line 149
Quoted 13 lines
drivers/mtd/spi-nor/otp.c +13
-0+SPI_MEM_OP_NO_DUMMY , + SPI_MEM_OP_NO_DATA); + +spi_nor_spimem_setup_op (nor, &op, nor->write_proto); + + ret =spi_mem_exec_op (nor->spimem, &op); + }else { + nor->bouncebuf[2 ] = addr &0xff ; + nor->bouncebuf[1 ] = (addr >>8 ) &0xff ; + nor->bouncebuf[0 ] = (addr >>16 ) &0xff ; + + ret =spi_nor_controller_ops_write_reg (nor,SPINOR_OP_ESECR , + nor->bouncebuf,3 );
Huh, sending address in the "data" parameter of write_reg() is strange. Wouldn't you be better off using spi_nor_controller_ops_erase()? It is an erase operation anyway so it should be the natural choice.
This was my first thought anyway. Then I looked at spi_nor_erase_sector(). It looks like controller_ops->erase is optional, and the fallback is this same technique.
I see a lot of similarities between this function and spi_nor_erase_sector(). So you can just swap out nor->erase_opcode and nor->addr_width and call that. I am not the biggest fan of this approach but it is widely used in the core so it should be fine. In fact, OTP read and write also use this approach.
Quoted 11 lines
drivers/mtd/spi-nor/otp.c +7
-0+ } +if (ret) +return ret; + +return spi_nor_wait_till_ready (nor); +} +static int spi_nor_otp_lock_bit_cr (unsigned int region) {static const int lock_bits[] = {SR2_LB1 ,SR2_LB2 ,SR2_LB3 };
drivers/mtd/spi-nor/otp.c static int spi_nor_mtd_otp_write(struct mtd_info *mtd, loff_t to, size_t len, · line 362
Quoted 5 lines
drivers/mtd/spi-nor/otp.c +1
-1@@ -316,12 +359,14 @@ static int spi_nor_mtd_otp_write(struct mtd_info *mtd, loff_t to, size_t len,return spi_nor_mtd_otp_read_write (mtd, to, len, retlen, buf, true); } -static int spi_nor_mtd_otp_lock (struct mtd_info *mtd,loff_t from,size_t len) +static int spi_nor_mtd_otp_lock_erase(struct mtd_info *mtd, loff_t from,
spi_nor_mtd_otp_lock_or_erase()? Or would it make it too long?
Anyway, maybe I am bikeshedding too much, but I don't like that you combine two completely independent operations into the same function because they have some common parts. You should make them two separate functions and see how many of the common parts can be split into independent subroutines.
Quoted 11 lines
drivers/mtd/spi-nor/otp.c +2
-0+ size_t len, bool is_erase) {struct spi_nor *nor =mtd_to_spi_nor (mtd);const struct spi_nor_otp_ops *ops = nor->params->otp.ops;const size_t rlen =spi_nor_otp_region_len (nor);unsigned int region; +loff_t rstart;int ret;if (from <0 || (from + len) >spi_nor_otp_size (nor))
drivers/mtd/spi-nor/otp.c static int spi_nor_mtd_otp_lock(struct mtd_info *mtd, loff_t from, size_t len) · line 388
Quoted 8 lines
drivers/mtd/spi-nor/otp.c +4
-1@@ -337,7 +382,13 @@ static int spi_nor_mtd_otp_lock(struct mtd_info *mtd, loff_t from, size_t len)while (len) { region =spi_nor_otp_offset_to_region (nor, from); - ret = ops->lock (nor, region); + +if (is_erase) { + rstart =spi_nor_otp_region_start (nor, region); + ret = ops->erase (nor, rstart);
This further highlights my point. There are subtle differences between erase and lock and having them in the same function might not be the best idea.
Quoted 51 lines
drivers/mtd/spi-nor/otp.c +21
-0+ }else { + ret = ops->lock (nor, region); + }if (ret) goto out;@@ -351,6 +402,23 @@ static int spi_nor_mtd_otp_lock(struct mtd_info *mtd, loff_t from, size_t len)return ret; } +static int spi_nor_mtd_otp_lock (struct mtd_info *mtd,loff_t from,size_t len) +{ +return spi_nor_mtd_otp_lock_erase (mtd, from, len, false); +} + +static int spi_nor_mtd_otp_erase (struct mtd_info *mtd,loff_t from,size_t len) +{ +struct spi_nor *nor =mtd_to_spi_nor (mtd); +const struct spi_nor_otp_ops *ops = nor->params->otp.ops; + +/* OTP erase is optional */ +if (!ops->erase) +return -EOPNOTSUPP ; + +return spi_nor_mtd_otp_lock_erase (mtd, from, len, true); +} +void spi_nor_otp_init (struct spi_nor *nor) {struct mtd_info *mtd = &nor->mtd;@@ -374,4 +442,5 @@ void spi_nor_otp_init(struct spi_nor *nor) mtd->_read_user_prot_reg = spi_nor_mtd_otp_read; mtd->_write_user_prot_reg = spi_nor_mtd_otp_write; mtd->_lock_user_prot_reg = spi_nor_mtd_otp_lock; + mtd->_erase_user_prot_reg = spi_nor_mtd_otp_erase; }drivers/mtd/spi-nor/winbond.c +1
-0@@ -139,6 +139,7 @@ static int winbond_set_4byte_addr_mode(struct spi_nor *nor, bool enable)static const struct spi_nor_otp_ops winbond_otp_ops = { .read = spi_nor_otp_read_secr, .write = spi_nor_otp_write_secr, + .erase = spi_nor_otp_erase_secr, .lock = spi_nor_otp_lock_sr2, .is_locked = spi_nor_otp_is_locked_sr2, };Signature · 1 line
2.20.1
Signature · 3 lines
Regards, Pratyush Yadav Texas Instruments Inc.
Hi Pratyush,
Am 2021-05-20 14:22, schrieb Pratyush Yadav:
Quoted 8 lines · Michael Walle
Quoted 2 lines
Winbond flashes with OTP support provide a command to erase the OTP data. This might come in handy during development.
I am not very familiar with the OTP feature. It is supposed to be "One Time Programmable". So does erasing the OTP area make it programmable again? Or it just erases the data and then the OTP region will forever be
0xff?
Its programmable and erasable until a lock bit is set, then you can't program or erase it anymore. So nowadays it isn't really OTP..
Quoted 1 line
Because if you can erase and reprogram it, how is it OTP at all?
Well, it isn't. Thus there wasn't an erase operation in the first place. But Tudor found it useful. Not sure if that applies to all SPI flashes, though.
See also
https://lore.kernel.org/linux-mtd/[email protected]/
Quoted 6 lines
Quoted 2 lines
This was tested with a Winbond W25Q32JW on a LS1028A SoC with the NXP FSPI controller.
I got the datasheet for this flash from
https://www.elinux.org/images/f/f5/Winbond-w25q32.pdf but it doesn't seem to mention the erase OTP command (0x44).
That seems to be an ancient flash, note it doesn't have any suffix.
https://www.winbond.com/resource-files/W25Q32JW%20SPI%20RevH%2003172020%20Plus.pdf
Quoted 36 lines
Quoted 36 lines
Signed-off-by Michael Walle <[email protected]>---
Changes since v1:
- fixed kernel docThere is also a patch for mtd-utils to add a small tool to issue the erase:
https://lore.kernel.org/linux-mtd/[email protected]/drivers/mtd/spi-nor/core.c | 4 +- drivers/mtd/spi-nor/core.h | 4 ++ drivers/mtd/spi-nor/otp.c | 73 ++++++++++++++++++++++++++++++++++- drivers/mtd/spi-nor/winbond.c | 1 + 4 files changed, 78 insertions(+), 4 deletions(-)drivers/mtd/spi-nor/core.c +2
-2@@ -166,8 +166,8 @@ static int spi_nor_controller_ops_read_reg(struct spi_nor *nor, u8 opcode, return nor->controller_ops->read_reg(nor, opcode, buf, len); } -static int spi_nor_controller_ops_write_reg (struct spi_nor *nor,u8 opcode, -const u8 *buf,size_t len) +int spi_nor_controller_ops_write_reg (struct spi_nor *nor,u8 opcode, +const u8 *buf,size_t len) {drivers/mtd/spi-nor/core.c +0
-0if (spi_nor_protocol_is_dtr (nor->reg_proto))return -EOPNOTSUPP ;drivers/mtd/spi-nor/core.h +0
-1--- a/drivers/mtd/spi-nor/core.h
Quoted 8 lines
drivers/mtd/spi-nor/core.h struct spi_nor_otp_ops { · line 217
Quoted 6 lines
+++
b/drivers/mtd/spi-nor/core.hdrivers/mtd/spi-nor/core.h +1
-0@@ -214,6 +214,7 @@ struct spi_nor_otp_ops {int (*write)(struct spi_nor *nor,loff_t addr,size_t len,const u8 *buf);int (*lock)(struct spi_nor *nor,unsigned int region); +int (*erase)(struct spi_nor *nor,loff_t addr);No doc update above?
Missed that.
Quoted 42 lines
Quoted 42 lines
drivers/mtd/spi-nor/core.h +2
-0int (*is_locked)(struct spi_nor *nor,unsigned int region); };@@ -481,6 +482,8 @@ extern const struct spi_nor_manufacturer spi_nor_xmc;void spi_nor_spimem_setup_op (const struct spi_nor *nor,struct spi_mem_op *op,const enum spi_nor_protocol proto); +int spi_nor_controller_ops_write_reg (struct spi_nor *nor,u8 opcode, +const u8 *buf,size_t len);int spi_nor_write_enable (struct spi_nor *nor);int spi_nor_write_disable (struct spi_nor *nor);int
spi_nor_set_4byte_addr_mode(struct spi_nor *nor, bool enable);drivers/mtd/spi-nor/core.h +1
-0@@ -507,6 +510,7 @@ ssize_t spi_nor_write_data(struct spi_nor *nor, loff_t to, size_t len, int spi_nor_otp_read_secr(struct spi_nor *nor, loff_t addr, size_t len,u8 *buf);int spi_nor_otp_write_secr (struct spi_nor *nor,loff_t addr,size_t len,const u8 *buf); +int spi_nor_otp_erase_secr (struct spi_nor *nor,loff_t addr);int
spi_nor_otp_lock_sr2(struct spi_nor *nor, unsigned int region); int spi_nor_otp_is_locked_sr2(structspi_nor*nor, unsigned int
region);drivers/mtd/spi-nor/otp.c +1
-0@@ -8,6 +8,7 @@#include <linux/log2.h> #include <linux/mtd/mtd.h> #include <linux/mtd/spi-nor.h> +#include <linux/spi/spi-mem.h> #include "core.h" @@ -111,6 +112,48 @@ int spi_nor_otp_write_secr(struct spi_nor *nor, loff_t addr, size_t len, return ret ?: written; }
Quoted 5 lines
drivers/mtd/spi-nor/otp.c int spi_nor_otp_write_secr(struct spi_nor *nor, loff_t addr, size_t len, · line 116
Quoted 2 lines
drivers/mtd/spi-nor/otp.c +2
-0+/** +* spi_nor_otp_erase_secr() - erase one OTP region Nitpick: The function is called
erase_secr()but the comment says erase region. Please use consistent wording.
Ok, will stick to the wording of the datasheet (which sounds quite odd, because its "security register"). This also applies to the read, write and lock.
Quoted 19 lines
Quoted 19 lines
drivers/mtd/spi-nor/otp.c +4
-0+* @nor: pointer to 'struct spi_nor' +* @addr: offset of the OTP region to be erased +* +* Erase one OTP region by using the SPINOR_OP_ESECR commands. This method is
+ * used on GigaDevice and Winbond flashes.
+ *
+ * Return: 0 on success, -errno otherwise
+ */drivers/mtd/spi-nor/otp.c +9
-0+int spi_nor_otp_erase_secr (struct spi_nor *nor,loff_t addr) +{ +int ret; + + ret =spi_nor_write_enable (nor); +if (ret) +return ret; + +if (nor->spimem) {
Quoted 8 lines
drivers/mtd/spi-nor/otp.c int spi_nor_otp_write_secr(struct spi_nor *nor, loff_t addr, size_t len, · line 136
Quoted 3 lines
drivers/mtd/spi-nor/otp.c +3
-0+struct spi_mem_op op = + SPI_MEM_OP(SPI_MEM_OP_CMD(SPINOR_OP_ESECR, 0), + SPI_MEM_OP_ADDR(3, addr, 0),Only 3 address bytes needed? Can the OTP region ever require 4 byte addressing? For example, say the flash is switched to 4 byte addressing for the main region. Would it still expect 3 byte addressing for OTP ops?
It seems you're right. Looking at larger flashes there are sometimes 4 bytes. See for example ch 8.2.44
https://www.winbond.com/resource-files/w25m512jwxiq%20spi%20rev%20c%2012242018.pdf
Thus it seems it should be fixed for the programming and reading, too. Unfortunately, I cannot test any of this.
Quoted 9 lines
Quoted 9 lines
drivers/mtd/spi-nor/otp.c +9
-0+SPI_MEM_OP_NO_DUMMY , + SPI_MEM_OP_NO_DATA); + +spi_nor_spimem_setup_op (nor, &op, nor->write_proto); + + ret =spi_mem_exec_op (nor->spimem, &op); + }else { + nor->bouncebuf[2 ] = addr &0xff ; + nor->bouncebuf[1 ] = (addr >>8 ) &0xff ;
Quoted 8 lines
drivers/mtd/spi-nor/otp.c int spi_nor_otp_write_secr(struct spi_nor *nor, loff_t addr, size_t len, · line 149
Quoted 4 lines
drivers/mtd/spi-nor/otp.c +4
-0+ nor->bouncebuf[0 ] = (addr >>16 ) &0xff ; + + ret =spi_nor_controller_ops_write_reg (nor,SPINOR_OP_ESECR , + nor->bouncebuf,3 );Huh, sending address in the "data" parameter of
write_reg()is strange. Wouldn't you be better off usingspi_nor_controller_ops_erase()? It is an erase operation anyway so it should be the natural choice.
Its the same as in spi_nor_erase_sector() if there is no spi_nor_controller_ops_erase(). spi_nor_controller_ops_erase() is just for erasing a sector (thus I'd assume it implies SPINOR_OP_SE).
Hm.. I should have read on.
Quoted 9 lines
This was my first thought anyway. Then I looked at
spi_nor_erase_sector(). It looks likecontroller_ops->eraseis optional, and the fallback is this same technique.I see a lot of similarities between this function and
spi_nor_erase_sector(). So you can just swap outnor->erase_opcodeandnor->addr_widthand call that. I am not the biggest fan of this approach but it is widely used in the core so it should be fine. In fact, OTP read and write also use this approach.
Ok, agreed on both points. This should also solve the "4 byte mode" problem, that is, just don't set addr_width.
Quoted 15 lines
Quoted 15 lines
drivers/mtd/spi-nor/otp.c +7
-0+ } +if (ret) +return ret; + +return spi_nor_wait_till_ready (nor); +} +static int spi_nor_otp_lock_bit_cr (unsigned int region) {static const int lock_bits[] = {SR2_LB1 ,SR2_LB2 ,SR2_LB3 };@@ -316,12 +359,14 @@ static int spi_nor_mtd_otp_write(struct mtd_info *mtd, loff_t to, size_t len, return spi_nor_mtd_otp_read_write(mtd, to, len, retlen, buf, true); }
Quoted 6 lines
drivers/mtd/spi-nor/otp.c static int spi_nor_mtd_otp_write(struct mtd_info · line 365
Quoted 4 lines
drivers/mtd/spi-nor/otp.c +1
-1-static int spi_nor_mtd_otp_lock(struct mtd_info *mtd, loff_t from, size_t len) +static int spi_nor_mtd_otp_lock_erase(struct mtd_info *mtd, loff_t from,
spi_nor_mtd_otp_lock_or_erase()? Or would it make it too long?
I'm fine with both, its just that the read/write doesn't have an "or" neither ;)
Quoted 5 lines
Anyway, maybe I am bikeshedding too much, but I don't like that you combine two completely independent operations into the same function because they have some common parts. You should make them two separate functions and see how many of the common parts can be split into independent subroutines.
Given that the whole boilerplate before and after the erase/lock is exactly the same, even the while loop is the same, I don't see how it can easily be split. Well, you could rename the function to some generic spi_nor_mtd_walk() - which would imply it might also be used for read/write, which is not true - and provide a callback function. But I don't see how this is would make it easier to read. And this is just an implemention local to this module.
Quoted 80 lines
Quoted 11 lines
drivers/mtd/spi-nor/otp.c +2
-0+ size_t len, bool is_erase) {struct spi_nor *nor =mtd_to_spi_nor (mtd);const struct spi_nor_otp_ops *ops = nor->params->otp.ops;const size_t rlen =spi_nor_otp_region_len (nor);unsigned int region; +loff_t rstart;drivers/mtd/spi-nor/otp.c +0
-0int ret;if (from <0 || (from + len) >spi_nor_otp_size (nor))drivers/mtd/spi-nor/otp.c static int spi_nor_mtd_otp_lock(struct mtd_info · line 389
Quoted 9 lines
drivers/mtd/spi-nor/otp.c +4
-1@@ -337,7 +382,13 @@ static int spi_nor_mtd_otp_lock(struct mtd_info *mtd, loff_t from, size_t len)while (len) { region =spi_nor_otp_offset_to_region (nor, from); - ret = ops->lock (nor, region); + +if (is_erase) { + rstart =spi_nor_otp_region_start (nor, region); + ret = ops->erase (nor, rstart);This further highlights my point. There are subtle differences between erase and lock and having them in the same function might not be the best idea.
Quoted 55 lines
drivers/mtd/spi-nor/otp.c +20
-0+ }else { + ret = ops->lock (nor, region); + }if (ret) goto out;@@ -351,6 +402,23 @@ static int spi_nor_mtd_otp_lock(struct mtd_info *mtd, loff_t from, size_t len)return ret; } +static int spi_nor_mtd_otp_lock (struct mtd_info *mtd,loff_t from,size_t len) +{ +return spi_nor_mtd_otp_lock_erase (mtd, from, len, false); +} + +static int spi_nor_mtd_otp_erase (struct mtd_info *mtd,loff_t from,size_t len) +{ +struct spi_nor *nor =mtd_to_spi_nor (mtd); +const struct spi_nor_otp_ops *ops = nor->params->otp.ops; + +/* OTP erase is optional */ +if (!ops->erase) +return -EOPNOTSUPP ; + +return spi_nor_mtd_otp_lock_erase (mtd, from, len, true); +} +void
spi_nor_otp_init(struct spi_nor *nor)
{drivers/mtd/spi-nor/otp.c +1
-0struct mtd_info *mtd = &nor->mtd;@@ -374,4 +442,5 @@ void spi_nor_otp_init(struct spi_nor *nor) mtd->_read_user_prot_reg = spi_nor_mtd_otp_read; mtd->_write_user_prot_reg = spi_nor_mtd_otp_write; mtd->_lock_user_prot_reg = spi_nor_mtd_otp_lock; + mtd->_erase_user_prot_reg = spi_nor_mtd_otp_erase; }drivers/mtd/spi-nor/winbond.c +1
-0@@ -139,6 +139,7 @@ static int winbond_set_4byte_addr_mode(struct spi_nor *nor, bool enable)static const struct spi_nor_otp_ops winbond_otp_ops = { .read = spi_nor_otp_read_secr, .write = spi_nor_otp_write_secr, + .erase = spi_nor_otp_erase_secr, .lock = spi_nor_otp_lock_sr2, .is_locked = spi_nor_otp_is_locked_sr2,};
--
2.20.1
Signature · 1 line
-michael
Quoted 15 lines · Michael Walle
Hi Pratyush,
Am 2021-05-20 14:22, schrieb Pratyush Yadav:
Quoted 8 lines · Michael Walle
Quoted 2 lines
Winbond flashes with OTP support provide a command to erase the OTP data. This might come in handy during development.
I am not very familiar with the OTP feature. It is supposed to be "One Time Programmable". So does erasing the OTP area make it programmable again? Or it just erases the data and then the OTP region will forever be
0xff?Its programmable and erasable until a lock bit is set, then you can't program or erase it anymore. So nowadays it isn't really OTP..
Quoted 8 lines
Quoted 1 line
Because if you can erase and reprogram it, how is it OTP at all?
Well, it isn't. Thus there wasn't an erase operation in the first place. But Tudor found it useful. Not sure if that applies to all SPI flashes, though.
See also
https://lore.kernel.org/linux-mtd/[email protected]/
Right. I remember seeing this. I was just curious how this whole system is supposed to work.
Quoted 11 lines
Quoted 7 lines
Quoted 3 lines
This was tested with a Winbond W25Q32JW on a LS1028A SoC with the NXP FSPI controller.
I got the datasheet for this flash from
https://www.elinux.org/images/f/f5/Winbond-w25q32.pdf but it doesn't seem to mention the erase OTP command (0x44).That seems to be an ancient flash, note it doesn't have any suffix.
https://www.winbond.com/resource-files/W25Q32JW%20SPI%20RevH%2003172020%20Plus.pdf
Thanks.
Quoted 96 lines
Quoted 37 lines
Quoted 37 lines
Signed-off-by Michael Walle <[email protected]>---
Changes since v1:
- fixed kernel docThere is also a patch for mtd-utils to add a small tool to issue the erase:
https://lore.kernel.org/linux-mtd/[email protected]/drivers/mtd/spi-nor/core.c | 4 +- drivers/mtd/spi-nor/core.h | 4 ++ drivers/mtd/spi-nor/otp.c | 73 ++++++++++++++++++++++++++++++++++- drivers/mtd/spi-nor/winbond.c | 1 + 4 files changed, 78 insertions(+), 4 deletions(-)drivers/mtd/spi-nor/core.c +2
-2@@ -166,8 +166,8 @@ static int spi_nor_controller_ops_read_reg(struct spi_nor *nor, u8 opcode, return nor->controller_ops->read_reg(nor, opcode, buf, len); } -static int spi_nor_controller_ops_write_reg (struct spi_nor *nor,u8 opcode, -const u8 *buf,size_t len) +int spi_nor_controller_ops_write_reg (struct spi_nor *nor,u8 opcode, +const u8 *buf,size_t len) {drivers/mtd/spi-nor/core.c +0
-0if (spi_nor_protocol_is_dtr (nor->reg_proto))return -EOPNOTSUPP ;drivers/mtd/spi-nor/core.h +0
-1--- a/drivers/mtd/spi-nor/core.hQuoted 8 lines
drivers/mtd/spi-nor/core.h struct spi_nor_otp_ops { · line 217
Quoted 6 lines
+++
b/drivers/mtd/spi-nor/core.hdrivers/mtd/spi-nor/core.h +1
-0@@ -214,6 +214,7 @@ struct spi_nor_otp_ops {int (*write)(struct spi_nor *nor,loff_t addr,size_t len,const u8 *buf);int (*lock)(struct spi_nor *nor,unsigned int region); +int (*erase)(struct spi_nor *nor,loff_t addr);No doc update above?
Missed that.
Quoted 42 lines
Quoted 42 lines
drivers/mtd/spi-nor/core.h +2
-0int (*is_locked)(struct spi_nor *nor,unsigned int region); };@@ -481,6 +482,8 @@ extern const struct spi_nor_manufacturer spi_nor_xmc;void spi_nor_spimem_setup_op (const struct spi_nor *nor,struct spi_mem_op *op,const enum spi_nor_protocol proto); +int spi_nor_controller_ops_write_reg (struct spi_nor *nor,u8 opcode, +const u8 *buf,size_t len);int spi_nor_write_enable (struct spi_nor *nor);int spi_nor_write_disable (struct spi_nor *nor);int
spi_nor_set_4byte_addr_mode(struct spi_nor *nor, bool enable);drivers/mtd/spi-nor/core.h +1
-0@@ -507,6 +510,7 @@ ssize_t spi_nor_write_data(struct spi_nor *nor, loff_t to, size_t len, int spi_nor_otp_read_secr(struct spi_nor *nor, loff_t addr, size_t len,u8 *buf);int spi_nor_otp_write_secr (struct spi_nor *nor,loff_t addr,size_t len,const u8 *buf); +int spi_nor_otp_erase_secr (struct spi_nor *nor,loff_t addr);int
spi_nor_otp_lock_sr2(struct spi_nor *nor, unsigned int region); int spi_nor_otp_is_locked_sr2(structspi_nor*nor, unsigned int
region);drivers/mtd/spi-nor/otp.c +1
-0@@ -8,6 +8,7 @@#include <linux/log2.h> #include <linux/mtd/mtd.h> #include <linux/mtd/spi-nor.h> +#include <linux/spi/spi-mem.h> #include "core.h" @@ -111,6 +112,48 @@ int spi_nor_otp_write_secr(struct spi_nor *nor, loff_t addr, size_t len, return ret ?: written; }Quoted 5 lines
drivers/mtd/spi-nor/otp.c int spi_nor_otp_write_secr(struct spi_nor *nor, loff_t addr, size_t len, · line 116
Quoted 2 lines
drivers/mtd/spi-nor/otp.c +2
-0+/** +* spi_nor_otp_erase_secr() - erase one OTP region Nitpick: The function is called
erase_secr()but the comment says erase region. Please use consistent wording.
Quoted 3 lines
Ok, will stick to the wording of the datasheet (which sounds quite odd, because
its "security register"). This also applies to the read, write and lock.
Ah, its "security register". I thought it was an unusual way to shorten sector (sect is the more common one I've seen).
Quoted 29 lines
Quoted 20 lines
Quoted 20 lines
drivers/mtd/spi-nor/otp.c +4
-0+* @nor: pointer to 'struct spi_nor' +* @addr: offset of the OTP region to be erased +* +* Erase one OTP region by using the SPINOR_OP_ESECR commands. This method is
+ * used on GigaDevice and Winbond flashes.
+ *
+ * Return: 0 on success, -errno otherwise
+ */drivers/mtd/spi-nor/otp.c +9
-0+int spi_nor_otp_erase_secr (struct spi_nor *nor,loff_t addr) +{ +int ret; + + ret =spi_nor_write_enable (nor); +if (ret) +return ret; + +if (nor->spimem) {Quoted 8 lines
drivers/mtd/spi-nor/otp.c int spi_nor_otp_write_secr(struct spi_nor *nor, loff_t addr, size_t len, · line 136
Quoted 3 lines
drivers/mtd/spi-nor/otp.c +3
-0+struct spi_mem_op op = + SPI_MEM_OP(SPI_MEM_OP_CMD(SPINOR_OP_ESECR, 0), + SPI_MEM_OP_ADDR(3, addr, 0),Only 3 address bytes needed? Can the OTP region ever require 4 byte addressing? For example, say the flash is switched to 4 byte addressing for the main region. Would it still expect 3 byte addressing for OTP ops?
Quoted 7 lines
It seems you're right. Looking at larger flashes there are sometimes 4 bytes. See for example ch 8.2.44
https://www.winbond.com/resource-files/w25m512jwxiq%20spi%20rev%20c%2012242018.pdf
Thus it seems it should be fixed for the programming and reading, too. Unfortunately, I cannot test any of this.
I don't think any such flash is supported currently, right? So in that case we won't at least introduce any new regressions when making this untested change. Whenever someone adds support for one of these flashes, we can ask them to test this as well.
Quoted 69 lines
Quoted 10 lines
Quoted 10 lines
drivers/mtd/spi-nor/otp.c +9
-0+SPI_MEM_OP_NO_DUMMY , + SPI_MEM_OP_NO_DATA); + +spi_nor_spimem_setup_op (nor, &op, nor->write_proto); + + ret =spi_mem_exec_op (nor->spimem, &op); + }else { + nor->bouncebuf[2 ] = addr &0xff ; + nor->bouncebuf[1 ] = (addr >>8 ) &0xff ;Quoted 8 lines
drivers/mtd/spi-nor/otp.c int spi_nor_otp_write_secr(struct spi_nor *nor, loff_t addr, size_t len, · line 149
Quoted 4 lines
drivers/mtd/spi-nor/otp.c +4
-0+ nor->bouncebuf[0 ] = (addr >>16 ) &0xff ; + + ret =spi_nor_controller_ops_write_reg (nor,SPINOR_OP_ESECR , + nor->bouncebuf,3 );Huh, sending address in the "data" parameter of
write_reg()is strange. Wouldn't you be better off usingspi_nor_controller_ops_erase()? It is an erase operation anyway so it should be the natural choice.Its the same as in
spi_nor_erase_sector()if there is nospi_nor_controller_ops_erase().spi_nor_controller_ops_erase()is just for erasing a sector (thus I'd assume it impliesSPINOR_OP_SE).Hm.. I should have read on.
Quoted 9 lines
This was my first thought anyway. Then I looked at
spi_nor_erase_sector(). It looks likecontroller_ops->eraseis optional, and the fallback is this same technique.I see a lot of similarities between this function and
spi_nor_erase_sector(). So you can just swap outnor->erase_opcodeandnor->addr_widthand call that. I am not the biggest fan of this approach but it is widely used in the core so it should be fine. In fact, OTP read and write also use this approach.Ok, agreed on both points. This should also solve the "4 byte mode" problem, that is, just don't set
addr_width.Quoted 15 lines
Quoted 15 lines
drivers/mtd/spi-nor/otp.c +7
-0+ } +if (ret) +return ret; + +return spi_nor_wait_till_ready (nor); +} +static int spi_nor_otp_lock_bit_cr (unsigned int region) {static const int lock_bits[] = {SR2_LB1 ,SR2_LB2 ,SR2_LB3 };@@ -316,12 +359,14 @@ static int spi_nor_mtd_otp_write(struct mtd_info *mtd, loff_t to, size_t len, return spi_nor_mtd_otp_read_write(mtd, to, len, retlen, buf, true); }Quoted 6 lines
drivers/mtd/spi-nor/otp.c static int spi_nor_mtd_otp_write(struct · line 365
Quoted 4 lines
drivers/mtd/spi-nor/otp.c +1
-1-static int spi_nor_mtd_otp_lock(struct mtd_info *mtd, loff_t from, size_t len) +static int spi_nor_mtd_otp_lock_erase(struct mtd_info *mtd, loff_t from,
spi_nor_mtd_otp_lock_or_erase()? Or would it make it too long?I'm fine with both, its just that the read/write doesn't have an "or" neither ;)
Quoted 5 lines
Anyway, maybe I am bikeshedding too much, but I don't like that you combine two completely independent operations into the same function because they have some common parts. You should make them two separate functions and see how many of the common parts can be split into independent subroutines.
Quoted 7 lines
Given that the whole boilerplate before and after the erase/lock is exactly the same, even the while loop is the same, I don't see how it can easily be split. Well, you could rename the function to some generic
spi_nor_mtd_walk()- which would imply it might also be used for read/write, which is not true - and provide a callback function. But I don't see how this is would make it easier to read. And this is just an implemention local to this module.
My suggestion was to make two copies of the same code, and then see if you can consolidate some in a clean subroutine. If that is not possible, then you can just leave the code duplicated in two places. It is not that much duplication so it should be fine IMO.
But I won't press too much on this point. I will leave it to your judgement on what works better. Just want to make sure you understand my point completely.
Quoted 32 lines
Quoted 32 lines
Quoted 12 lines
drivers/mtd/spi-nor/otp.c +2
-0+ size_t len, bool is_erase) {struct spi_nor *nor =mtd_to_spi_nor (mtd);const struct spi_nor_otp_ops *ops = nor->params->otp.ops;const size_t rlen =spi_nor_otp_region_len (nor);unsigned int region; +loff_t rstart;drivers/mtd/spi-nor/otp.c +0
-0int ret;if (from <0 || (from + len) >spi_nor_otp_size (nor))drivers/mtd/spi-nor/otp.c static int spi_nor_mtd_otp_lock(struct mtd_info · line 389
Quoted 9 lines
drivers/mtd/spi-nor/otp.c +4
-1@@ -337,7 +382,13 @@ static int spi_nor_mtd_otp_lock(struct mtd_info *mtd, loff_t from, size_t len)while (len) { region =spi_nor_otp_offset_to_region (nor, from); - ret = ops->lock (nor, region); + +if (is_erase) { + rstart =spi_nor_otp_region_start (nor, region); + ret = ops->erase (nor, rstart);This further highlights my point. There are subtle differences between erase and lock and having them in the same function might not be the best idea.
Quoted 6 lines
drivers/mtd/spi-nor/otp.c +3
-0+ }else { + ret = ops->lock (nor, region); + }if (ret) goto out;
[...]
Signature · 3 lines
Regards, Pratyush Yadav Texas Instruments Inc.
Am 2021-05-20 15:49, schrieb Pratyush Yadav:
Quoted 3 lines · Michael Walle
Quoted 2 lines
Am 2021-05-20 14:22, schrieb Pratyush Yadav:
Quoted 1 line · Michael Walle
..
Quoted 23 lines
Quoted 23 lines
Quoted 9 lines
Quoted 9 lines
drivers/mtd/spi-nor/otp.c +9
-0+int spi_nor_otp_erase_secr (struct spi_nor *nor,loff_t addr) +{ +int ret; + + ret =spi_nor_write_enable (nor); +if (ret) +return ret; + +if (nor->spimem) {Quoted 8 lines
drivers/mtd/spi-nor/otp.c int spi_nor_otp_write_secr(struct spi_nor *nor, loff_t addr, size_t len, · line 136
Quoted 3 lines
drivers/mtd/spi-nor/otp.c +3
-0+struct spi_mem_op op = + SPI_MEM_OP(SPI_MEM_OP_CMD(SPINOR_OP_ESECR, 0), + SPI_MEM_OP_ADDR(3, addr, 0),Only 3 address bytes needed? Can the OTP region ever require 4 byte addressing? For example, say the flash is switched to 4 byte addressing for the main region. Would it still expect 3 byte addressing for OTP ops?
It seems you're right. Looking at larger flashes there are sometimes 4 bytes. See for example ch 8.2.44
https://www.winbond.com/resource-files/w25m512jwxiq%20spi%20rev%20c%2012242018.pdf
Quoted 7 lines
Quoted 2 lines
Thus it seems it should be fixed for the programming and reading, too. Unfortunately, I cannot test any of this.
I don't think any such flash is supported currently, right? So in that case we won't at least introduce any new regressions when making this untested change. Whenever someone adds support for one of these flashes, we can ask them to test this as well.
yep.
..
Quoted 22 lines
Quoted 14 lines
Quoted 4 lines
Quoted 2 lines
+static int spi_nor_mtd_otp_lock_erase(struct
mtd_info*mtd,loff_tfrom,
spi_nor_mtd_otp_lock_or_erase()? Or would it make it too long?I'm fine with both, its just that the read/write doesn't have an "or" neither ;)
Quoted 5 lines
Anyway, maybe I am bikeshedding too much, but I don't like that you combine two completely independent operations into the same function because they have some common parts. You should make them two separate functions and see how many of the common parts can be split into independent subroutines.
Quoted 7 lines
Given that the whole boilerplate before and after the erase/lock is exactly the same, even the while loop is the same, I don't see how it can easily be split. Well, you could rename the function to some generic
spi_nor_mtd_walk()- which would imply it might also be used for read/write, which is not true - and provide a callback function. But I don't see how this is would make it easier to read. And this is just an implemention local to this module.
Quoted 8 lines
My suggestion was to make two copies of the same code, and then see if you can consolidate some in a clean subroutine. If that is not possible, then you can just leave the code duplicated in two places. It is not that much duplication so it should be fine IMO.
But I won't press too much on this point. I will leave it to your judgement on what works better. Just want to make sure you understand my point completely.
I get your point. But I really don't like the code duplication.
Quoted 13 lines
Quoted 13 lines
Quoted 13 lines
Quoted 13 lines
drivers/mtd/spi-nor/otp.c +2
-0+ size_t len, bool is_erase) {struct spi_nor *nor =mtd_to_spi_nor (mtd);const struct spi_nor_otp_ops *ops = nor->params->otp.ops;const size_t rlen =spi_nor_otp_region_len (nor);unsigned int region; +loff_t rstart;int ret;if (from <0 || (from + len) >spi_nor_otp_size (nor))@@ -337,7 +382,13 @@ static int spi_nor_mtd_otp_lock(struct mtd_info *mtd, loff_t from, size_t len)
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
drivers/mtd/spi-nor/otp.c static int spi_nor_mtd_otp_lock(struct mtd_info *mtd, loff_t from, size_t len) · line 388
Quoted 7 lines
drivers/mtd/spi-nor/otp.c +4
-1while (len) { region =spi_nor_otp_offset_to_region (nor, from); - ret = ops->lock (nor, region); + +if (is_erase) { + rstart =spi_nor_otp_region_start (nor, region); + ret = ops->erase (nor, rstart);This further highlights my point. There are subtle differences between erase and lock and having them in the same function might not be the best idea.
Maybe the argument for the locking is wrong. Future will tell. The start address of a region and the number of a region is actually equivalent. So maybe ->lock should also take the start address. But then you'd go from address -> region -> address -> region.
At the moment its modelled after how winbond and macronix flashes implement these ops.
See here for an old version of the support for macronix(-like) flashes:
https://lore.kernel.org/linux-mtd/[email protected]/
-michael