Skip to contentSkip to conversation

mtd: spi-nor: core: set mtd->eraseregions for

PATCH Superseded [email protected] 3 participants 7 messages Jan 23, 2024 – Feb 5, 2024

Subsystems (2)

v2 of 4 Superseded Latest is v4 →

lore
Share & tools
lore
#0 lore raw

v2 cover mtd: spi-nor: core: set mtd->eraseregions for

From: Takahiro Kuwano <[email protected]>

In v2, reworked spi_nor_erase_region to stop bitmask encoding in offset. And added n_regions member to spi_nor_erase_map.

Takahiro Kuwano (2):
mtd: spi-nor: core: rework struct spi_nor_erase_region
mtd: spi-nor: core: set mtd->eraseregions for non-uniform erase map

 drivers/mtd/spi-nor/core.c | 94 +++++++++++++++++++++++++++++---------
 drivers/mtd/spi-nor/core.h | 30 +++++-------
 drivers/mtd/spi-nor/sfdp.c | 31 ++++++-------
 3 files changed, 98 insertions(+), 57 deletions(-)
Signature · 6 lines
2.34.1


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

PATCH v2 1/2 mtd: spi-nor: core: rework struct spi_nor_erase_region

From: Takahiro Kuwano <[email protected]>

Encoding bitmask flags into offset worsen the code readability. The erase type mask and flags should be stored in dedicated members. Also, erase_map.uniform_erase_type can be removed as it is redundant.

---
 drivers/mtd/spi-nor/core.c | 35 +++++++++++++++--------------------
 drivers/mtd/spi-nor/core.h | 28 ++++++++++------------------
 drivers/mtd/spi-nor/sfdp.c | 30 +++++++++++++-----------------
 3 files changed, 38 insertions(+), 55 deletions(-)
drivers/mtd/spi-nor/core.c +15 -20
index 1b0c6770c14e..5b2f13d0888e 100644
@@ -1150,7 +1150,7 @@ static u8 spi_nor_convert_3to4_erase(u8 opcode)
 
 static bool spi_nor_has_uniform_erase(const struct spi_nor *nor)
 {
-	return !!nor->params->erase_map.uniform_erase_type;
+	return !!nor->params->erase_map.uniform_region.erase_mask;
 }
 
 static void spi_nor_set_4byte_opcodes(struct spi_nor *nor)
@@ -1534,7 +1534,6 @@ spi_nor_find_best_erase_type(const struct spi_nor_erase_map *map,
 	const struct spi_nor_erase_type *erase;
 	u32 rem;
 	int i;
-	u8 erase_mask = region->offset & SNOR_ERASE_TYPE_MASK;
 
 	/*
 	 * Erase types are ordered by size, with the smallest erase type at
@@ -1542,7 +1541,7 @@ spi_nor_find_best_erase_type(const struct spi_nor_erase_map *map,
 	 */
 	for (i = SNOR_ERASE_TYPE_MAX - 1; i >= 0; i--) {
 		/* Does the erase region support the tested erase type? */
-		if (!(erase_mask & BIT(i)))
+		if (!(region->erase_mask & BIT(i)))
 			continue;
 
 		erase = &map->erase_type[i];
@@ -1550,7 +1549,7 @@ spi_nor_find_best_erase_type(const struct spi_nor_erase_map *map,
 			continue;
 
 		/* Alignment is not mandatory for overlaid regions */
-		if (region->offset & SNOR_OVERLAID_REGION &&
+		if (region->flags & SNOR_OVERLAID_REGION &&
 		    region->size <= len)
 			return erase;
 
@@ -1568,12 +1567,12 @@ spi_nor_find_best_erase_type(const struct spi_nor_erase_map *map,
 
 static u64 spi_nor_region_is_last(const struct spi_nor_erase_region *region)
 {
-	return region->offset & SNOR_LAST_REGION;
+	return region->flags & SNOR_LAST_REGION;
 }
 
 static u64 spi_nor_region_end(const struct spi_nor_erase_region *region)
 {
-	return (region->offset & ~SNOR_ERASE_FLAGS_MASK) + region->size;
+	return region->offset + region->size;
 }
 
 /**
@@ -1604,16 +1603,14 @@ static struct spi_nor_erase_region *
 spi_nor_find_erase_region(const struct spi_nor_erase_map *map, u64 addr)
 {
 	struct spi_nor_erase_region *region = map->regions;
-	u64 region_start = region->offset & ~SNOR_ERASE_FLAGS_MASK;
-	u64 region_end = region_start + region->size;
+	u64 region_end = spi_nor_region_end(region);
 
-	while (addr < region_start || addr >= region_end) {
+	while (addr < region->offset || addr >= region_end) {
 		region = spi_nor_region_next(region);
 		if (!region)
 			return ERR_PTR(-EINVAL);
 
-		region_start = region->offset & ~SNOR_ERASE_FLAGS_MASK;
-		region_end = region_start + region->size;
+		region_end = spi_nor_region_end(region);
 	}
 
 	return region;
@@ -1641,7 +1638,7 @@ spi_nor_init_erase_cmd(const struct spi_nor_erase_region *region,
 	cmd->opcode = erase->opcode;
 	cmd->count = 1;
 
-	if (region->offset & SNOR_OVERLAID_REGION)
+	if (region->flags & SNOR_OVERLAID_REGION)
 		cmd->size = region->size;
 	else
 		cmd->size = erase->size;
@@ -1700,7 +1697,7 @@ static int spi_nor_init_erase_cmd_list(struct spi_nor *nor,
 
 		if (prev_erase != erase ||
 		    erase->size != cmd->size ||
-		    region->offset & SNOR_OVERLAID_REGION) {
+		    region->flags & SNOR_OVERLAID_REGION) {
 			cmd = spi_nor_init_erase_cmd(region, erase);
 			if (IS_ERR(cmd)) {
 				ret = PTR_ERR(cmd);
@@ -2439,12 +2436,11 @@ void spi_nor_mask_erase_type(struct spi_nor_erase_type *erase)
 void spi_nor_init_uniform_erase_map(struct spi_nor_erase_map *map,
 				    u8 erase_mask, u64 flash_size)
 {
-	/* Offset 0 with erase_mask and SNOR_LAST_REGION bit set */
-	map->uniform_region.offset = (erase_mask & SNOR_ERASE_TYPE_MASK) |
-				     SNOR_LAST_REGION;
+	map->uniform_region.offset = 0;
 	map->uniform_region.size = flash_size;
+	map->uniform_region.erase_mask = erase_mask;
+	map->uniform_region.flags = SNOR_LAST_REGION;
 	map->regions = &map->uniform_region;
-	map->uniform_erase_type = erase_mask;
 }
 
 int spi_nor_post_bfpt_fixups(struct spi_nor *nor,
@@ -2539,7 +2535,7 @@ spi_nor_select_uniform_erase(struct spi_nor_erase_map *map,
 {
 	const struct spi_nor_erase_type *tested_erase, *erase = NULL;
 	int i;
-	u8 uniform_erase_type = map->uniform_erase_type;
+	u8 uniform_erase_type = map->uniform_region.erase_mask;
 
 	for (i = SNOR_ERASE_TYPE_MAX - 1; i >= 0; i--) {
 		if (!(uniform_erase_type & BIT(i)))
@@ -2573,8 +2569,7 @@ spi_nor_select_uniform_erase(struct spi_nor_erase_map *map,
 		return NULL;
 
 	/* Disable all other Sector Erase commands. */
-	map->uniform_erase_type &= ~SNOR_ERASE_TYPE_MASK;
-	map->uniform_erase_type |= BIT(erase - map->erase_type);
+	map->uniform_region.erase_mask = BIT(erase - map->erase_type);
 	return erase;
 }
 
drivers/mtd/spi-nor/core.h +10 -18
index 9217379b9cfe..e002de22b18a 100644
@@ -233,27 +233,25 @@ struct spi_nor_erase_command {
 /**
  * struct spi_nor_erase_region - Structure to describe a SPI NOR erase region
  * @offset:		the offset in the data array of erase region start.
- *			LSB bits are used as a bitmask encoding flags to
- *			determine if this region is overlaid, if this region is
- *			the last in the SPI NOR flash memory and to indicate
- *			all the supported erase commands inside this region.
- *			The erase types are sorted in ascending order with the
- *			smallest Erase Type size being at BIT(0).
  * @size:		the size of the region in bytes.
+ * @erase_mask:		bitmask to indicate all the supported erase commands
+ *			inside this region. The erase types are sorted in
+ *			ascending order with the smallest Erase Type size being
+ *			at BIT(0).
+ * @flags:		flags to determine if this region is overlaid, if this
+ *			region is the last in the SPI NOR flash memory
  */
 struct spi_nor_erase_region {
 	u64		offset;
 	u64		size;
+	u8		erase_mask;
+	u8		flags;
 };
 
 #define SNOR_ERASE_TYPE_MAX	4
-#define SNOR_ERASE_TYPE_MASK	GENMASK_ULL(SNOR_ERASE_TYPE_MAX - 1, 0)
 
-#define SNOR_LAST_REGION	BIT(4)
-#define SNOR_OVERLAID_REGION	BIT(5)
-
-#define SNOR_ERASE_FLAGS_MAX	6
-#define SNOR_ERASE_FLAGS_MASK	GENMASK_ULL(SNOR_ERASE_FLAGS_MAX - 1, 0)
+#define SNOR_LAST_REGION	BIT(0)
+#define SNOR_OVERLAID_REGION	BIT(1)
 
 /**
  * struct spi_nor_erase_map - Structure to describe the SPI NOR erase map
@@ -266,17 +264,11 @@ struct spi_nor_erase_region {
  *			The erase types are sorted in ascending order, with the
  *			smallest Erase Type size being the first member in the
  *			erase_type array.
- * @uniform_erase_type:	bitmask encoding erase types that can erase the
- *			entire memory. This member is completed at init by
- *			uniform and non-uniform SPI NOR flash memories if they
- *			support at least one erase type that can erase the
- *			entire memory.
  */
 struct spi_nor_erase_map {
 	struct spi_nor_erase_region	*regions;
 	struct spi_nor_erase_region	uniform_region;
 	struct spi_nor_erase_type	erase_type[SNOR_ERASE_TYPE_MAX];
-	u8				uniform_erase_type;
 };
 
 /**
drivers/mtd/spi-nor/sfdp.c +13 -17
index b3b11dfed789..c8d8b4e5b7e6 100644
@@ -389,17 +389,14 @@ static u8 spi_nor_sort_erase_mask(struct spi_nor_erase_map *map, u8 erase_mask)
 static void spi_nor_regions_sort_erase_types(struct spi_nor_erase_map *map)
 {
 	struct spi_nor_erase_region *region = map->regions;
-	u8 region_erase_mask, sorted_erase_mask;
+	u8 sorted_erase_mask;
 
 	while (region) {
-		region_erase_mask = region->offset & SNOR_ERASE_TYPE_MASK;
-
 		sorted_erase_mask = spi_nor_sort_erase_mask(map,
-							    region_erase_mask);
+							    region->erase_mask);
 
 		/* Overwrite erase mask. */
-		region->offset = (region->offset & ~SNOR_ERASE_TYPE_MASK) |
-				 sorted_erase_mask;
+		region->erase_mask = sorted_erase_mask;
 
 		region = spi_nor_region_next(region);
 	}
@@ -553,8 +550,6 @@ static int spi_nor_parse_bfpt(struct spi_nor *nor,
 	 * selecting the uniform erase.
 	 */
 	spi_nor_regions_sort_erase_types(map);
-	map->uniform_erase_type = map->uniform_region.offset &
-				  SNOR_ERASE_TYPE_MASK;
 
 	/* Stop here if not JESD216 rev A or later. */
 	if (bfpt_header->length == BFPT_DWORD_MAX_JESD216)
@@ -781,12 +776,12 @@ static const u32 *spi_nor_get_map_in_use(struct spi_nor *nor, const u32 *smpt,
 
 static void spi_nor_region_mark_end(struct spi_nor_erase_region *region)
 {
-	region->offset |= SNOR_LAST_REGION;
+	region->flags |= SNOR_LAST_REGION;
 }
 
 static void spi_nor_region_mark_overlay(struct spi_nor_erase_region *region)
 {
-	region->offset |= SNOR_OVERLAID_REGION;
+	region->flags |= SNOR_OVERLAID_REGION;
 }
 
 /**
@@ -848,9 +843,10 @@ static int spi_nor_init_non_uniform_erase_map(struct spi_nor *nor,
 	/* Populate regions. */
 	for (i = 0; i < region_count; i++) {
 		j = i + 1; /* index for the region dword */
+		region[i].offset = offset;
 		region[i].size = SMPT_MAP_REGION_SIZE(smpt[j]);
 		erase_type = SMPT_MAP_REGION_ERASE_TYPE(smpt[j]);
-		region[i].offset = offset | erase_type;
+		region[i].erase_mask = erase_type;
 
 		spi_nor_region_check_overlay(&region[i], erase, erase_type);
 
@@ -866,21 +862,21 @@ static int spi_nor_init_non_uniform_erase_map(struct spi_nor *nor,
 		 */
 		regions_erase_type |= erase_type;
 
-		offset = (region[i].offset & ~SNOR_ERASE_FLAGS_MASK) +
-			 region[i].size;
+		offset = region[i].offset + region[i].size;
 	}
 	spi_nor_region_mark_end(&region[i - 1]);
 
-	save_uniform_erase_type = map->uniform_erase_type;
-	map->uniform_erase_type = spi_nor_sort_erase_mask(map,
-							  uniform_erase_type);
+	save_uniform_erase_type = map->uniform_region.erase_mask;
+	map->uniform_region.erase_mask =
+				spi_nor_sort_erase_mask(map,
+							uniform_erase_type);
 
 	if (!regions_erase_type) {
 		/*
 		 * Roll back to the previous uniform_erase_type mask, SMPT is
 		 * broken.
 		 */
-		map->uniform_erase_type = save_uniform_erase_type;
+		map->uniform_region.erase_mask = save_uniform_erase_type;
 		return -EINVAL;
 	}
 
Signature · 6 lines
2.34.1


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

Re: [PATCH v2 1/2] mtd: spi-nor: core: rework struct spi_nor_erase_region

Hi,

Thanks for working on this! This is going to look better now.

Quoted 5 lines

From: Takahiro Kuwano <[email protected]>

Encoding bitmask flags into offset worsen the code readability. The erase type mask and flags should be stored in dedicated members. Also, erase_map.uniform_erase_type can be removed as it is redundant.

Nice!

Quoted 5 lines
---
 drivers/mtd/spi-nor/core.c | 35 +++++++++++++++--------------------
 drivers/mtd/spi-nor/core.h | 28 ++++++++++------------------
 drivers/mtd/spi-nor/sfdp.c | 30 +++++++++++++-----------------

I think debugfs.c is missing here and needs to be changed, too.

drivers/mtd/spi-nor/core.c static u8 spi_nor_convert_3to4_erase(u8 opcode) · line 1153

Quoted 12 lines
 3 files changed, 38 insertions(+), 55 deletions(-)
drivers/mtd/spi-nor/core.c +1 -1
index 1b0c6770c14e..5b2f13d0888e 100644
@@ -1150,7 +1150,7 @@ static u8 spi_nor_convert_3to4_erase(u8 opcode)
 
 static bool spi_nor_has_uniform_erase(const struct spi_nor *nor)
 {
-	return !!nor->params->erase_map.uniform_erase_type;
+	return !!nor->params->erase_map.uniform_region.erase_mask;

I you are going to change this line, please drop the unneeded "!!".

Quoted 33 lines
drivers/mtd/spi-nor/core.c +0 -1
 }
 
 static void spi_nor_set_4byte_opcodes(struct spi_nor *nor)
@@ -1534,7 +1534,6 @@ spi_nor_find_best_erase_type(const struct 
 spi_nor_erase_map *map,
 	const struct spi_nor_erase_type *erase;
 	u32 rem;
 	int i;
-	u8 erase_mask = region->offset & SNOR_ERASE_TYPE_MASK;
 
 	/*
drivers/mtd/spi-nor/core.c +1 -1
 	 * Erase types are ordered by size, with the smallest erase type at
@@ -1542,7 +1541,7 @@ spi_nor_find_best_erase_type(const struct 
 spi_nor_erase_map *map,
 	 */
 	for (i = SNOR_ERASE_TYPE_MAX - 1; i >= 0; i--) {
 		/* Does the erase region support the tested erase type? */
-		if (!(erase_mask & BIT(i)))
+		if (!(region->erase_mask & BIT(i)))
 			continue;
 
drivers/mtd/spi-nor/core.c +1 -1
 		erase = &map->erase_type[i];
@@ -1550,7 +1549,7 @@ spi_nor_find_best_erase_type(const struct 
 spi_nor_erase_map *map,
 			continue;
 
 		/* Alignment is not mandatory for overlaid regions */
-		if (region->offset & SNOR_OVERLAID_REGION &&
+		if (region->flags & SNOR_OVERLAID_REGION &&
 		    region->size <= len)
 			return erase;

drivers/mtd/spi-nor/core.c spi_nor_find_best_erase_type(const struct · line 1573

Quoted 8 lines
drivers/mtd/spi-nor/core.c +1 -1
@@ -1568,12 +1567,12 @@ spi_nor_find_best_erase_type(const struct 
 spi_nor_erase_map *map,
 
 static u64 spi_nor_region_is_last(const struct spi_nor_erase_region 
 *region)
 {
-	return region->offset & SNOR_LAST_REGION;
+	return region->flags & SNOR_LAST_REGION;
 }

Do you think we can get rid of this, too? Just save the number of erase regions instead of having this flag. IIRC Tudor had also suggested this.

Quoted 188 lines
drivers/mtd/spi-nor/core.c +1 -1
 static u64 spi_nor_region_end(const struct spi_nor_erase_region 
 *region)
 {
-	return (region->offset & ~SNOR_ERASE_FLAGS_MASK) + region->size;
+	return region->offset + region->size;
 }

/**

drivers/mtd/spi-nor/core.c +3 -5
@@ -1604,16 +1603,14 @@ static struct spi_nor_erase_region *
 spi_nor_find_erase_region(const struct spi_nor_erase_map *map, u64 
 addr)
 {
 	struct spi_nor_erase_region *region = map->regions;
-	u64 region_start = region->offset & ~SNOR_ERASE_FLAGS_MASK;
-	u64 region_end = region_start + region->size;
+	u64 region_end = spi_nor_region_end(region);
 
-	while (addr < region_start || addr >= region_end) {
+	while (addr < region->offset || addr >= region_end) {
 		region = spi_nor_region_next(region);
 		if (!region)
 			return ERR_PTR(-EINVAL);
 
-		region_start = region->offset & ~SNOR_ERASE_FLAGS_MASK;
-		region_end = region_start + region->size;
+		region_end = spi_nor_region_end(region);
 	}
 
drivers/mtd/spi-nor/core.c +1 -1
 	return region;
@@ -1641,7 +1638,7 @@ spi_nor_init_erase_cmd(const struct 
 spi_nor_erase_region *region,
 	cmd->opcode = erase->opcode;
 	cmd->count = 1;
 
-	if (region->offset & SNOR_OVERLAID_REGION)
+	if (region->flags & SNOR_OVERLAID_REGION)
 		cmd->size = region->size;
 	else
drivers/mtd/spi-nor/core.c +1 -1
 		cmd->size = erase->size;
@@ -1700,7 +1697,7 @@ static int spi_nor_init_erase_cmd_list(struct 
 spi_nor *nor,
 
 		if (prev_erase != erase ||
 		    erase->size != cmd->size ||
-		    region->offset & SNOR_OVERLAID_REGION) {
+		    region->flags & SNOR_OVERLAID_REGION) {
 			cmd = spi_nor_init_erase_cmd(region, erase);
 			if (IS_ERR(cmd)) {
drivers/mtd/spi-nor/core.c +3 -4
 				ret = PTR_ERR(cmd);
@@ -2439,12 +2436,11 @@ void spi_nor_mask_erase_type(struct 
 spi_nor_erase_type *erase)
 void spi_nor_init_uniform_erase_map(struct spi_nor_erase_map *map,
 				    u8 erase_mask, u64 flash_size)
 {
-	/* Offset 0 with erase_mask and SNOR_LAST_REGION bit set */
-	map->uniform_region.offset = (erase_mask & SNOR_ERASE_TYPE_MASK) |
-				     SNOR_LAST_REGION;
+	map->uniform_region.offset = 0;
 	map->uniform_region.size = flash_size;
+	map->uniform_region.erase_mask = erase_mask;
+	map->uniform_region.flags = SNOR_LAST_REGION;
 	map->regions = &map->uniform_region;
-	map->uniform_erase_type = erase_mask;
 }
 

int spi_nor_post_bfpt_fixups(struct spi_nor *nor,

drivers/mtd/spi-nor/core.c +1 -1
@@ -2539,7 +2535,7 @@ spi_nor_select_uniform_erase(struct 
 spi_nor_erase_map *map,
 {
 	const struct spi_nor_erase_type *tested_erase, *erase = NULL;
 	int i;
-	u8 uniform_erase_type = map->uniform_erase_type;
+	u8 uniform_erase_type = map->uniform_region.erase_mask;
 
 	for (i = SNOR_ERASE_TYPE_MAX - 1; i >= 0; i--) {
drivers/mtd/spi-nor/core.c +1 -2
 		if (!(uniform_erase_type & BIT(i)))
@@ -2573,8 +2569,7 @@ spi_nor_select_uniform_erase(struct 
 spi_nor_erase_map *map,
 		return NULL;
 
 	/* Disable all other Sector Erase commands. */
-	map->uniform_erase_type &= ~SNOR_ERASE_TYPE_MASK;
-	map->uniform_erase_type |= BIT(erase - map->erase_type);
+	map->uniform_region.erase_mask = BIT(erase - map->erase_type);
 	return erase;
 }
drivers/mtd/spi-nor/core.h +0 -0
index 9217379b9cfe..e002de22b18a 100644
@@ -233,27 +233,25 @@ struct spi_nor_erase_command {
 /**
  * struct spi_nor_erase_region - Structure to describe a SPI NOR erase 

region
* @offset: the offset in the data array of erase region start.
- * LSB bits are used as a bitmask encoding flags to
- * determine if this region is overlaid, if this region is
- * the last in the SPI NOR flash memory and to indicate
- * all the supported erase commands inside this region.
- * The erase types are sorted in ascending order with the
- * smallest Erase Type size being at BIT(0).
* @size: the size of the region in bytes.
+ * @erase_mask: bitmask to indicate all the supported erase commands
+ * inside this region. The erase types are sorted in
+ * ascending order with the smallest Erase Type size being
+ * at BIT(0).
+ * @flags: flags to determine if this region is overlaid, if this
+ * region is the last in the SPI NOR flash memory
*/
struct spi_nor_erase_region {

drivers/mtd/spi-nor/core.h +4 -6
 	u64		offset;
 	u64		size;
+	u8		erase_mask;
+	u8		flags;
 };
 
 #define SNOR_ERASE_TYPE_MAX	4
-#define SNOR_ERASE_TYPE_MASK	GENMASK_ULL(SNOR_ERASE_TYPE_MAX - 1, 0)
 
-#define SNOR_LAST_REGION	BIT(4)
-#define SNOR_OVERLAID_REGION	BIT(5)
-
-#define SNOR_ERASE_FLAGS_MAX	6
-#define SNOR_ERASE_FLAGS_MASK	GENMASK_ULL(SNOR_ERASE_FLAGS_MAX - 1, 0)
+#define SNOR_LAST_REGION	BIT(0)
+#define SNOR_OVERLAID_REGION	BIT(1)
 
 /**
  * struct spi_nor_erase_map - Structure to describe the SPI NOR erase 

map

drivers/mtd/spi-nor/core.h +0 -1
@@ -266,17 +264,11 @@ struct spi_nor_erase_region {
  *			The erase types are sorted in ascending order, with the
  *			smallest Erase Type size being the first member in the
  *			erase_type array.
- * @uniform_erase_type:	bitmask encoding erase types that can erase 

the
- * entire memory. This member is completed at init by
- * uniform and non-uniform SPI NOR flash memories if they
- * support at least one erase type that can erase the
- * entire memory.
*/
struct spi_nor_erase_map {

drivers/mtd/spi-nor/core.h +0 -1
 	struct spi_nor_erase_region	*regions;
 	struct spi_nor_erase_region	uniform_region;
 	struct spi_nor_erase_type	erase_type[SNOR_ERASE_TYPE_MAX];
-	u8				uniform_erase_type;
 };
 
 /**
drivers/mtd/spi-nor/sfdp.c +3 -6
index b3b11dfed789..c8d8b4e5b7e6 100644
@@ -389,17 +389,14 @@ static u8 spi_nor_sort_erase_mask(struct 
 spi_nor_erase_map *map, u8 erase_mask)
 static void spi_nor_regions_sort_erase_types(struct spi_nor_erase_map 
 *map)
 {
 	struct spi_nor_erase_region *region = map->regions;
-	u8 region_erase_mask, sorted_erase_mask;
+	u8 sorted_erase_mask;
 
 	while (region) {
-		region_erase_mask = region->offset & SNOR_ERASE_TYPE_MASK;
-
 		sorted_erase_mask = spi_nor_sort_erase_mask(map,
-							    region_erase_mask);
+							    region->erase_mask);
 
 		/* Overwrite erase mask. */
-		region->offset = (region->offset & ~SNOR_ERASE_TYPE_MASK) |
-				 sorted_erase_mask;
+		region->erase_mask = sorted_erase_mask;
 
drivers/mtd/spi-nor/sfdp.c +0 -2
 		region = spi_nor_region_next(region);
 	}
@@ -553,8 +550,6 @@ static int spi_nor_parse_bfpt(struct spi_nor *nor,
 	 * selecting the uniform erase.
 	 */
 	spi_nor_regions_sort_erase_types(map);
-	map->uniform_erase_type = map->uniform_region.offset &
-				  SNOR_ERASE_TYPE_MASK;
 
 	/* Stop here if not JESD216 rev A or later. */
 	if (bfpt_header->length == BFPT_DWORD_MAX_JESD216)

drivers/mtd/spi-nor/sfdp.c static const u32 *spi_nor_get_map_in_use(struct · line 782

Quoted 8 lines
drivers/mtd/spi-nor/sfdp.c +1 -1
@@ -781,12 +776,12 @@ static const u32 *spi_nor_get_map_in_use(struct 
 spi_nor *nor, const u32 *smpt,
 
 static void spi_nor_region_mark_end(struct spi_nor_erase_region 
 *region)
 {
-	region->offset |= SNOR_LAST_REGION;
+	region->flags |= SNOR_LAST_REGION;
 }

I'd assume this will go away if you have some kind of .n_erase_maps

drivers/mtd/spi-nor/sfdp.c static const u32 *spi_nor_get_map_in_use(struct spi_nor *nor, const u32 *smpt, · line 784

Quoted 6 lines
drivers/mtd/spi-nor/sfdp.c +1 -1
 static void spi_nor_region_mark_overlay(struct spi_nor_erase_region 
 *region)
 {
-	region->offset |= SNOR_OVERLAID_REGION;
+	region->flags |= SNOR_OVERLAID_REGION;

And this I'd drop, too. No need for a function to set just a flag.

-michael

Quoted 34 lines
drivers/mtd/spi-nor/sfdp.c +0 -0
 }

/**

drivers/mtd/spi-nor/sfdp.c +7 -6
@@ -848,9 +843,10 @@ static int 
 spi_nor_init_non_uniform_erase_map(struct spi_nor *nor,
 	/* Populate regions. */
 	for (i = 0; i < region_count; i++) {
 		j = i + 1; /* index for the region dword */
+		region[i].offset = offset;
 		region[i].size = SMPT_MAP_REGION_SIZE(smpt[j]);
 		erase_type = SMPT_MAP_REGION_ERASE_TYPE(smpt[j]);
-		region[i].offset = offset | erase_type;
+		region[i].erase_mask = erase_type;
 
 		spi_nor_region_check_overlay(&region[i], erase, erase_type);
@@ -866,21 +862,21 @@ static int 
 spi_nor_init_non_uniform_erase_map(struct spi_nor *nor,
 		 */
 		regions_erase_type |= erase_type;
 
-		offset = (region[i].offset & ~SNOR_ERASE_FLAGS_MASK) +
-			 region[i].size;
+		offset = region[i].offset + region[i].size;
 	}
 	spi_nor_region_mark_end(&region[i - 1]);
 
-	save_uniform_erase_type = map->uniform_erase_type;
-	map->uniform_erase_type = spi_nor_sort_erase_mask(map,
-							  uniform_erase_type);
+	save_uniform_erase_type = map->uniform_region.erase_mask;
+	map->uniform_region.erase_mask =
+				spi_nor_sort_erase_mask(map,
+							uniform_erase_type);

drivers/mtd/spi-nor/sfdp.c static int · line 882

Quoted 10 lines
drivers/mtd/spi-nor/sfdp.c +1 -1
 
 	if (!regions_erase_type) {
 		/*
 		 * Roll back to the previous uniform_erase_type mask, SMPT is
 		 * broken.
 		 */
-		map->uniform_erase_type = save_uniform_erase_type;
+		map->uniform_region.erase_mask = save_uniform_erase_type;
 		return -EINVAL;
 	}

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

#3 lore raw

Re: [PATCH v2 1/2] mtd: spi-nor: core: rework struct spi_nor_erase_region

Hi Michael,

Quoted 66 lines · Michael Walle

Hi,

Thanks for working on this! This is going to look better now.

Quoted 5 lines

From: Takahiro Kuwano <[email protected]>

Encoding bitmask flags into offset worsen the code readability. The erase type mask and flags should be stored in dedicated members. Also, erase_map.uniform_erase_type can be removed as it is redundant.

Nice!

Quoted 5 lines

---

 drivers/mtd/spi-nor/core.c | 35 +++++++++++++++--------------------
 drivers/mtd/spi-nor/core.h | 28 ++++++++++------------------
 drivers/mtd/spi-nor/sfdp.c | 30 +++++++++++++-----------------

I think debugfs.c is missing here and needs to be changed, too.

drivers/mtd/spi-nor/core.c static u8 spi_nor_convert_3to4_erase(u8 opcode) · line 1153

Quoted 12 lines
 3 files changed, 38 insertions(+), 55 deletions(-)
drivers/mtd/spi-nor/core.c +1 -1
index 1b0c6770c14e..5b2f13d0888e 100644
@@ -1150,7 +1150,7 @@ static u8 spi_nor_convert_3to4_erase(u8 opcode)
 
  static bool spi_nor_has_uniform_erase(const struct spi_nor *nor)
  {
-    return !!nor->params->erase_map.uniform_erase_type;
+    return !!nor->params->erase_map.uniform_region.erase_mask;

I you are going to change this line, please drop the unneeded "!!".

Quoted 31 lines
drivers/mtd/spi-nor/core.c +2 -3
  }
 
  static void spi_nor_set_4byte_opcodes(struct spi_nor *nor)
@@ -1534,7 +1534,6 @@ spi_nor_find_best_erase_type(const struct spi_nor_erase_map *map,
      const struct spi_nor_erase_type *erase;
      u32 rem;
      int i;
-    u8 erase_mask = region->offset & SNOR_ERASE_TYPE_MASK;
 
      /*
       * Erase types are ordered by size, with the smallest erase type at
@@ -1542,7 +1541,7 @@ spi_nor_find_best_erase_type(const struct spi_nor_erase_map *map,
       */
      for (i = SNOR_ERASE_TYPE_MAX - 1; i >= 0; i--) {
          /* Does the erase region support the tested erase type? */
-        if (!(erase_mask & BIT(i)))
+        if (!(region->erase_mask & BIT(i)))
              continue;
 
          erase = &map->erase_type[i];
@@ -1550,7 +1549,7 @@ spi_nor_find_best_erase_type(const struct spi_nor_erase_map *map,
              continue;
 
          /* Alignment is not mandatory for overlaid regions */
-        if (region->offset & SNOR_OVERLAID_REGION &&
+        if (region->flags & SNOR_OVERLAID_REGION &&
              region->size <= len)
              return erase;
 
@@ -1568,12 +1567,12 @@ spi_nor_find_best_erase_type(const struct spi_nor_erase_map *map,
 
Quoted 10 lines

drivers/mtd/spi-nor/core.c spi_nor_find_best_erase_type(const struct spi_nor_erase_map *map, · line 1571

Quoted 5 lines
drivers/mtd/spi-nor/core.c +1 -1
  static u64 spi_nor_region_is_last(const struct spi_nor_erase_region *region)
  {
-    return region->offset & SNOR_LAST_REGION;
+    return region->flags & SNOR_LAST_REGION;
  }

Do you think we can get rid of this, too? Just save the number of erase regions instead of having this flag. IIRC Tudor had also suggested this.

Yes, I will remove this and rework related functions.

If we remove this flag, the SNOR_OVERLAID_REGION will be only one flag. How about removing the SNOR_OVERLAID_REGION as well, and change 'region->flags' to a bool value like 'region->overlaid'?

Quoted 228 lines
Quoted 176 lines
drivers/mtd/spi-nor/core.c +5 -7
  static u64 spi_nor_region_end(const struct spi_nor_erase_region *region)
  {
-    return (region->offset & ~SNOR_ERASE_FLAGS_MASK) + region->size;
+    return region->offset + region->size;
  }
 
  /**
@@ -1604,16 +1603,14 @@ static struct spi_nor_erase_region *
  spi_nor_find_erase_region(const struct spi_nor_erase_map *map, u64 addr)
  {
      struct spi_nor_erase_region *region = map->regions;
-    u64 region_start = region->offset & ~SNOR_ERASE_FLAGS_MASK;
-    u64 region_end = region_start + region->size;
+    u64 region_end = spi_nor_region_end(region);
 
-    while (addr < region_start || addr >= region_end) {
+    while (addr < region->offset || addr >= region_end) {
          region = spi_nor_region_next(region);
          if (!region)
              return ERR_PTR(-EINVAL);
 
-        region_start = region->offset & ~SNOR_ERASE_FLAGS_MASK;
-        region_end = region_start + region->size;
+        region_end = spi_nor_region_end(region);
      }
 
      return region;
@@ -1641,7 +1638,7 @@ spi_nor_init_erase_cmd(const struct spi_nor_erase_region *region,
      cmd->opcode = erase->opcode;
      cmd->count = 1;
 
-    if (region->offset & SNOR_OVERLAID_REGION)
+    if (region->flags & SNOR_OVERLAID_REGION)
          cmd->size = region->size;

     else
         cmd->size = erase->size;

drivers/mtd/spi-nor/core.c +0 -0
@@ -1700,7 +1697,7 @@ static int spi_nor_init_erase_cmd_list(struct spi_nor *nor,
 

         if (prev_erase != erase ||
             erase->size != cmd->size ||
-            region->offset & SNOR_OVERLAID_REGION) { +            region->flags & SNOR_OVERLAID_REGION) { cmd = spi_nor_init_erase_cmd(region, erase); if (IS_ERR(cmd)) {
                 ret = PTR_ERR(cmd);

drivers/mtd/spi-nor/core.c +5 -7
@@ -2439,12 +2436,11 @@ void spi_nor_mask_erase_type(struct spi_nor_erase_type *erase)
  void spi_nor_init_uniform_erase_map(struct spi_nor_erase_map *map,
                      u8 erase_mask, u64 flash_size)
  {
-    /* Offset 0 with erase_mask and SNOR_LAST_REGION bit set */
-    map->uniform_region.offset = (erase_mask & SNOR_ERASE_TYPE_MASK) |
-                     SNOR_LAST_REGION;
+    map->uniform_region.offset = 0;
      map->uniform_region.size = flash_size;
+    map->uniform_region.erase_mask = erase_mask;
+    map->uniform_region.flags = SNOR_LAST_REGION;
      map->regions = &map->uniform_region;
-    map->uniform_erase_type = erase_mask;
  }
 
  int spi_nor_post_bfpt_fixups(struct spi_nor *nor,
@@ -2539,7 +2535,7 @@ spi_nor_select_uniform_erase(struct spi_nor_erase_map *map,
  {
      const struct spi_nor_erase_type *tested_erase, *erase = NULL;
      int i;
-    u8 uniform_erase_type = map->uniform_erase_type;
+    u8 uniform_erase_type = map->uniform_region.erase_mask;
 
      for (i = SNOR_ERASE_TYPE_MAX - 1; i >= 0; i--) {
          if (!(uniform_erase_type & BIT(i)))
@@ -2573,8 +2569,7 @@ spi_nor_select_uniform_erase(struct spi_nor_erase_map *map,
          return NULL;
 
      /* Disable all other Sector Erase commands. */
-    map->uniform_erase_type &= ~SNOR_ERASE_TYPE_MASK;
-    map->uniform_erase_type |= BIT(erase - map->erase_type);
+    map->uniform_region.erase_mask = BIT(erase - map->erase_type);
      return erase;
  }
 
drivers/mtd/spi-nor/core.h +10 -18
index 9217379b9cfe..e002de22b18a 100644
@@ -233,27 +233,25 @@ struct spi_nor_erase_command {
  /**
   * struct spi_nor_erase_region - Structure to describe a SPI NOR erase region
   * @offset:        the offset in the data array of erase region start.
- *            LSB bits are used as a bitmask encoding flags to
- *            determine if this region is overlaid, if this region is
- *            the last in the SPI NOR flash memory and to indicate
- *            all the supported erase commands inside this region.
- *            The erase types are sorted in ascending order with the
- *            smallest Erase Type size being at BIT(0).
   * @size:        the size of the region in bytes.
+ * @erase_mask:        bitmask to indicate all the supported erase commands
+ *            inside this region. The erase types are sorted in
+ *            ascending order with the smallest Erase Type size being
+ *            at BIT(0).
+ * @flags:        flags to determine if this region is overlaid, if this
+ *            region is the last in the SPI NOR flash memory
   */
  struct spi_nor_erase_region {
      u64        offset;
      u64        size;
+    u8        erase_mask;
+    u8        flags;
  };
 
  #define SNOR_ERASE_TYPE_MAX    4
-#define SNOR_ERASE_TYPE_MASK    GENMASK_ULL(SNOR_ERASE_TYPE_MAX - 1, 0)
 
-#define SNOR_LAST_REGION    BIT(4)
-#define SNOR_OVERLAID_REGION    BIT(5)
-
-#define SNOR_ERASE_FLAGS_MAX    6
-#define SNOR_ERASE_FLAGS_MASK    GENMASK_ULL(SNOR_ERASE_FLAGS_MAX - 1, 0)
+#define SNOR_LAST_REGION    BIT(0)
+#define SNOR_OVERLAID_REGION    BIT(1)
 
  /**
   * struct spi_nor_erase_map - Structure to describe the SPI NOR erase map
@@ -266,17 +264,11 @@ struct spi_nor_erase_region {
   *            The erase types are sorted in ascending order, with the
   *            smallest Erase Type size being the first member in the
   *            erase_type array.
- * @uniform_erase_type:    bitmask encoding erase types that can erase the
- *            entire memory. This member is completed at init by
- *            uniform and non-uniform SPI NOR flash memories if they
- *            support at least one erase type that can erase the
- *            entire memory.
   */
  struct spi_nor_erase_map {
      struct spi_nor_erase_region    *regions;
      struct spi_nor_erase_region    uniform_region;
      struct spi_nor_erase_type    erase_type[SNOR_ERASE_TYPE_MAX];
-    u8                uniform_erase_type;
  };
 
  /**
drivers/mtd/spi-nor/sfdp.c +3 -8
index b3b11dfed789..c8d8b4e5b7e6 100644
@@ -389,17 +389,14 @@ static u8 spi_nor_sort_erase_mask(struct spi_nor_erase_map *map, u8 erase_mask)
  static void spi_nor_regions_sort_erase_types(struct spi_nor_erase_map *map)
  {
      struct spi_nor_erase_region *region = map->regions;
-    u8 region_erase_mask, sorted_erase_mask;
+    u8 sorted_erase_mask;
 
      while (region) {
-        region_erase_mask = region->offset & SNOR_ERASE_TYPE_MASK;
-
          sorted_erase_mask = spi_nor_sort_erase_mask(map,
-                                region_erase_mask);
+                                region->erase_mask);
 
          /* Overwrite erase mask. */
-        region->offset = (region->offset & ~SNOR_ERASE_TYPE_MASK) |
-                 sorted_erase_mask;
+        region->erase_mask = sorted_erase_mask;
 
          region = spi_nor_region_next(region);
      }
@@ -553,8 +550,6 @@ static int spi_nor_parse_bfpt(struct spi_nor *nor,
       * selecting the uniform erase.
       */
      spi_nor_regions_sort_erase_types(map);
-    map->uniform_erase_type = map->uniform_region.offset &
-                  SNOR_ERASE_TYPE_MASK;
 
      /* Stop here if not JESD216 rev A or later. */
      if (bfpt_header->length == BFPT_DWORD_MAX_JESD216)

drivers/mtd/spi-nor/sfdp.c static const u32 *spi_nor_get_map_in_use(struct spi_nor *nor, const u32 *smpt, · line 780

Quoted 6 lines
drivers/mtd/spi-nor/sfdp.c +1 -1
@@ -781,12 +776,12 @@ static const u32 *spi_nor_get_map_in_use(struct spi_nor *nor, const u32 *smpt,
 
  static void spi_nor_region_mark_end(struct spi_nor_erase_region *region)
  {
-    region->offset |= SNOR_LAST_REGION;
+    region->flags |= SNOR_LAST_REGION;
  }

I'd assume this will go away if you have some kind of .n_erase_maps

drivers/mtd/spi-nor/sfdp.c static const u32 *spi_nor_get_map_in_use(struct spi_nor *nor, const u32 *smpt, · line 784

Quoted 5 lines
drivers/mtd/spi-nor/sfdp.c +1 -1
  static void spi_nor_region_mark_overlay(struct spi_nor_erase_region *region)
  {
-    region->offset |= SNOR_OVERLAID_REGION;
+    region->flags |= SNOR_OVERLAID_REGION;

And this I'd drop, too. No need for a function to set just a flag.

-michael

Quoted 33 lines
drivers/mtd/spi-nor/sfdp.c +0 -0
  }
 
  /**
@@ -848,9 +843,10 @@ static int spi_nor_init_non_uniform_erase_map(struct spi_nor *nor,
      /* Populate regions. */
      for (i = 0; i < region_count; i++) {

         j = i + 1; /* index for the region dword */ +        region[i].offset = offset; region[i].size = SMPT_MAP_REGION_SIZE(smpt[j]); erase_type = SMPT_MAP_REGION_ERASE_TYPE(smpt[j]); -        region[i].offset = offset | erase_type; +        region[i].erase_mask = erase_type;

         spi_nor_region_check_overlay(&region[i], erase, erase_type);

drivers/mtd/spi-nor/sfdp.c +5 -5
@@ -866,21 +862,21 @@ static int spi_nor_init_non_uniform_erase_map(struct spi_nor *nor,
           */
          regions_erase_type |= erase_type;
 
-        offset = (region[i].offset & ~SNOR_ERASE_FLAGS_MASK) +
-             region[i].size;
+        offset = region[i].offset + region[i].size;
      }
      spi_nor_region_mark_end(&region[i - 1]);
 
-    save_uniform_erase_type = map->uniform_erase_type;
-    map->uniform_erase_type = spi_nor_sort_erase_mask(map,
-                              uniform_erase_type);
+    save_uniform_erase_type = map->uniform_region.erase_mask;
+    map->uniform_region.erase_mask =
+                spi_nor_sort_erase_mask(map,
+                            uniform_erase_type);
 
Quoted 9 lines

drivers/mtd/spi-nor/sfdp.c static int spi_nor_init_non_uniform_erase_map(struct spi_nor *nor, · line 881

Quoted 9 lines
drivers/mtd/spi-nor/sfdp.c +1 -1
      if (!regions_erase_type) {
          /*
           * Roll back to the previous uniform_erase_type mask, SMPT is
           * broken.
           */
-        map->uniform_erase_type = save_uniform_erase_type;
+        map->uniform_region.erase_mask = save_uniform_erase_type;
          return -EINVAL;
      }

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

#4 lore raw

Re: [PATCH v2 1/2] mtd: spi-nor: core: rework struct spi_nor_erase_region

Quoted 9 lines · Takahiro Kuwano
Quoted 9 lines
Quoted 5 lines

 static u64 spi_nor_region_is_last(const struct spi_nor_erase_region *region) {
-    return region->offset & SNOR_LAST_REGION;
+    return region->flags & SNOR_LAST_REGION;
 }

Do you think we can get rid of this, too? Just save the number of erase regions instead of having this flag. IIRC Tudor had also suggested this.

Quoted 5 lines

Yes, I will remove this and rework related functions.

If we remove this flag, the SNOR_OVERLAID_REGION will be only one flag. How about removing the SNOR_OVERLAID_REGION as well, and change 'region->flags' to a bool value like 'region->overlaid'?

sounds good, yes. Thanks!

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

#5 lore raw

PATCH v2 2/2 mtd: spi-nor: core: set mtd->eraseregions for non-uniform erase map

In reply to [email protected]

From: Takahiro Kuwano <[email protected]>

Some of Infineon SPI NOR flash devices support hybrid sector layout that overlays 4KB sectors on a 256KB sector and SPI NOR framework recognizes that by parsing SMPT and construct params->erase_map. The hybrid sector layout is similar to CFI flash devices that have small sectors on top and/or bottom address. In case of CFI flash devices, the erase map information is parsed through CFI table and populated into mtd->eraseregions so that users can create MTD partitions that aligned with small sector boundaries. This patch provides the same capability to SPI NOR flash devices that have non-uniform erase map.

---
 drivers/mtd/spi-nor/core.c | 59 ++++++++++++++++++++++++++++++++++++--
 drivers/mtd/spi-nor/core.h |  2 ++
 drivers/mtd/spi-nor/sfdp.c |  1 +
 3 files changed, 60 insertions(+), 2 deletions(-)
drivers/mtd/spi-nor/core.c +57 -2
index 5b2f13d0888e..25702d604fc5 100644
@@ -2441,6 +2441,7 @@ void spi_nor_init_uniform_erase_map(struct spi_nor_erase_map *map,
 	map->uniform_region.erase_mask = erase_mask;
 	map->uniform_region.flags = SNOR_LAST_REGION;
 	map->regions = &map->uniform_region;
+	map->n_regions = 1;
 }
 
 int spi_nor_post_bfpt_fixups(struct spi_nor *nor,
@@ -3403,7 +3404,54 @@ static const struct flash_info *spi_nor_get_flash_info(struct spi_nor *nor,
 	return info;
 }
 
-static void spi_nor_set_mtd_info(struct spi_nor *nor)
+static u32
+spi_nor_get_region_erasesize(const struct spi_nor_erase_region *region,
+			     const struct spi_nor_erase_type *erase_type)
+{
+	u8 i;
+
+	if (region->flags & SNOR_OVERLAID_REGION)
+		return region->size;
+
+	for (i = SNOR_ERASE_TYPE_MAX - 1; i >= 0; i--) {
+		if (region->erase_mask & BIT(i))
+			return erase_type[i].size;
+	}
+
+	return 0;
+}
+
+static int spi_nor_set_mtd_eraseregions(struct spi_nor *nor)
+{
+	const struct spi_nor_erase_map *map = &nor->params->erase_map;
+	const struct spi_nor_erase_region *region = map->regions;
+	struct mtd_erase_region_info *mtd_region;
+	struct mtd_info *mtd = &nor->mtd;
+	u32 erasesize, i;
+
+	mtd_region = devm_kcalloc(nor->dev, map->n_regions, sizeof(*mtd_region),
+				  GFP_KERNEL);
+	if (!mtd_region)
+		return -ENOMEM;
+
+	for (i = 0; i < map->n_regions; i++) {
+		erasesize = spi_nor_get_region_erasesize(&region[i],
+							 map->erase_type);
+		if (!erasesize)
+			return -EINVAL;
+
+		mtd_region[i].erasesize = erasesize;
+		mtd_region[i].numblocks = div64_ul(region[i].size, erasesize);
+		mtd_region[i].offset = region[i].offset;
+	}
+
+	mtd->numeraseregions = map->n_regions;
+	mtd->eraseregions = mtd_region;
+
+	return 0;
+}
+
+static int spi_nor_set_mtd_info(struct spi_nor *nor)
 {
 	struct mtd_info *mtd = &nor->mtd;
 	struct device *dev = nor->dev;
@@ -3434,6 +3482,11 @@ static void spi_nor_set_mtd_info(struct spi_nor *nor)
 	mtd->_resume = spi_nor_resume;
 	mtd->_get_device = spi_nor_get_device;
 	mtd->_put_device = spi_nor_put_device;
+
+	if (!spi_nor_has_uniform_erase(nor))
+		return spi_nor_set_mtd_eraseregions(nor);
+
+	return 0;
 }
 
 static int spi_nor_hw_reset(struct spi_nor *nor)
@@ -3526,7 +3579,9 @@ int spi_nor_scan(struct spi_nor *nor, const char *name,
 		return ret;
 
 	/* No mtd_info fields should be used up to this point. */
-	spi_nor_set_mtd_info(nor);
+	ret = spi_nor_set_mtd_info(nor);
+	if (ret)
+		return ret;
 
 	dev_info(dev, "%s (%lld Kbytes)\n", info->name,
 			(long long)mtd->size >> 10);
drivers/mtd/spi-nor/core.h +2 -0
index e002de22b18a..fefa990525ff 100644
@@ -264,11 +264,13 @@ struct spi_nor_erase_region {
  *			The erase types are sorted in ascending order, with the
  *			smallest Erase Type size being the first member in the
  *			erase_type array.
+ * @n_regions:		number of erase regions.
  */
 struct spi_nor_erase_map {
 	struct spi_nor_erase_region	*regions;
 	struct spi_nor_erase_region	uniform_region;
 	struct spi_nor_erase_type	erase_type[SNOR_ERASE_TYPE_MAX];
+	unsigned int			n_regions;
 };
 
 /**
drivers/mtd/spi-nor/sfdp.c +1 -0
index c8d8b4e5b7e6..afe041f75f30 100644
@@ -836,6 +836,7 @@ static int spi_nor_init_non_uniform_erase_map(struct spi_nor *nor,
 	if (!region)
 		return -ENOMEM;
 	map->regions = region;
+	map->n_regions = region_count;
 
 	uniform_erase_type = 0xff;
 	regions_erase_type = 0;
Signature · 6 lines
2.34.1


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

Re: [PATCH v2 2/2] mtd: spi-nor: core: set mtd->eraseregions for non-uniform erase map

Hi,

Quoted 24 lines

From: Takahiro Kuwano <[email protected]>

Some of Infineon SPI NOR flash devices support hybrid sector layout that overlays 4KB sectors on a 256KB sector and SPI NOR framework recognizes that by parsing SMPT and construct params->erase_map. The hybrid sector layout is similar to CFI flash devices that have small sectors on top and/or bottom address. In case of CFI flash devices, the erase map information is parsed through CFI table and populated into mtd->eraseregions so that users can create MTD partitions that aligned with small sector boundaries. This patch provides the same capability to SPI NOR flash devices that have non-uniform erase map.

---
 drivers/mtd/spi-nor/core.c | 59 ++++++++++++++++++++++++++++++++++++--
 drivers/mtd/spi-nor/core.h |  2 ++
 drivers/mtd/spi-nor/sfdp.c |  1 +
 3 files changed, 60 insertions(+), 2 deletions(-)
drivers/mtd/spi-nor/core.c +0 -0
index 5b2f13d0888e..25702d604fc5 100644

drivers/mtd/spi-nor/core.c void spi_nor_init_uniform_erase_map(struct · line 2445

Quoted 5 lines
drivers/mtd/spi-nor/core.c +1 -0
@@ -2441,6 +2441,7 @@ void spi_nor_init_uniform_erase_map(struct 
 spi_nor_erase_map *map,
 	map->uniform_region.erase_mask = erase_mask;
 	map->uniform_region.flags = SNOR_LAST_REGION;
 	map->regions = &map->uniform_region;
+	map->n_regions = 1;

Ahh, here it is. So, this should go into the former patch and the SNOR_LAST_REGION flag should be dropped. They are redundant, right?

Quoted 63 lines
drivers/mtd/spi-nor/core.c +0 -0
 }
 

int spi_nor_post_bfpt_fixups(struct spi_nor *nor,

drivers/mtd/spi-nor/core.c +48 -1
@@ -3403,7 +3404,54 @@ static const struct flash_info 
 *spi_nor_get_flash_info(struct spi_nor *nor,
 	return info;
 }
 
-static void spi_nor_set_mtd_info(struct spi_nor *nor)
+static u32
+spi_nor_get_region_erasesize(const struct spi_nor_erase_region 
 *region,
+			     const struct spi_nor_erase_type *erase_type)
+{
+	u8 i;
+
+	if (region->flags & SNOR_OVERLAID_REGION)
+		return region->size;
+
+	for (i = SNOR_ERASE_TYPE_MAX - 1; i >= 0; i--) {
+		if (region->erase_mask & BIT(i))
+			return erase_type[i].size;
+	}
+
+	return 0;
+}
+
+static int spi_nor_set_mtd_eraseregions(struct spi_nor *nor)
+{
+	const struct spi_nor_erase_map *map = &nor->params->erase_map;
+	const struct spi_nor_erase_region *region = map->regions;
+	struct mtd_erase_region_info *mtd_region;
+	struct mtd_info *mtd = &nor->mtd;
+	u32 erasesize, i;
+
+	mtd_region = devm_kcalloc(nor->dev, map->n_regions, 
 sizeof(*mtd_region),
+				  GFP_KERNEL);
+	if (!mtd_region)
+		return -ENOMEM;
+
+	for (i = 0; i < map->n_regions; i++) {
+		erasesize = spi_nor_get_region_erasesize(&region[i],
+							 map->erase_type);
+		if (!erasesize)
+			return -EINVAL;
+
+		mtd_region[i].erasesize = erasesize;
+		mtd_region[i].numblocks = div64_ul(region[i].size, erasesize);
+		mtd_region[i].offset = region[i].offset;
+	}
+
+	mtd->numeraseregions = map->n_regions;
+	mtd->eraseregions = mtd_region;
+
+	return 0;
+}
+
+static int spi_nor_set_mtd_info(struct spi_nor *nor)

{

drivers/mtd/spi-nor/core.c +0 -0
 	struct mtd_info *mtd = &nor->mtd;
 	struct device *dev = nor->dev;

drivers/mtd/spi-nor/core.c static void spi_nor_set_mtd_info(struct spi_nor · line 3488

Quoted 7 lines
drivers/mtd/spi-nor/core.c +3 -0
@@ -3434,6 +3482,11 @@ static void spi_nor_set_mtd_info(struct spi_nor 
 *nor)
 	mtd->_resume = spi_nor_resume;
 	mtd->_get_device = spi_nor_get_device;
 	mtd->_put_device = spi_nor_put_device;
+
+	if (!spi_nor_has_uniform_erase(nor))
+		return spi_nor_set_mtd_eraseregions(nor);

Btw I wonder if we can set it in any case?

Apart from the n_regions thing, this looks good.

-michael

Quoted 47 lines
drivers/mtd/spi-nor/core.c +2 -0
+
+	return 0;
 }
 

static int spi_nor_hw_reset(struct spi_nor *nor)

drivers/mtd/spi-nor/core.c +3 -1
@@ -3526,7 +3579,9 @@ int spi_nor_scan(struct spi_nor *nor, const char 
 *name,
 		return ret;
 
 	/* No mtd_info fields should be used up to this point. */
-	spi_nor_set_mtd_info(nor);
+	ret = spi_nor_set_mtd_info(nor);
+	if (ret)
+		return ret;
 
 	dev_info(dev, "%s (%lld Kbytes)\n", info->name,
drivers/mtd/spi-nor/core.c +0 -0
 			(long long)mtd->size >> 10);
drivers/mtd/spi-nor/core.h +2 -0
index e002de22b18a..fefa990525ff 100644
@@ -264,11 +264,13 @@ struct spi_nor_erase_region {
  *			The erase types are sorted in ascending order, with the
  *			smallest Erase Type size being the first member in the
  *			erase_type array.
+ * @n_regions:		number of erase regions.
  */
 struct spi_nor_erase_map {
 	struct spi_nor_erase_region	*regions;
 	struct spi_nor_erase_region	uniform_region;
 	struct spi_nor_erase_type	erase_type[SNOR_ERASE_TYPE_MAX];
+	unsigned int			n_regions;
 };
 
 /**
drivers/mtd/spi-nor/sfdp.c +1 -0
index c8d8b4e5b7e6..afe041f75f30 100644
@@ -836,6 +836,7 @@ static int 
 spi_nor_init_non_uniform_erase_map(struct spi_nor *nor,
 	if (!region)
 		return -ENOMEM;
 	map->regions = region;
+	map->n_regions = region_count;
 
 	uniform_erase_type = 0xff;
Quoted 1 line

regions_erase_type = 0;

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