Commit 2fb038ea authored by Han Xu's avatar Han Xu Committed by Miquel Raynal
Browse files

mtd: rawnand: gpmi: Rename the variable ecc_chunk_size 



There is only one variable ecc_chunk_size in bch_geometry data
structure but two different field in BCH registers. The data0_size in
BCH_FLASH0LAYOUT0 and datan_size in BCH_FLASH0LAYOUT1 should have
dedicate variable since they might set to different values in some
cases. For instance, if need dedicate ecc for meta area, the data0_size
should be 0 rather than datan_size, but for all other cases, data0_size
still equals to datan_size and it won't bring any function change.

Signed-off-by: default avatarHan Xu <han.xu@nxp.com>
Signed-off-by: default avatarMiquel Raynal <miquel.raynal@bootlin.com>
Link: https://lore.kernel.org/linux-mtd/20220412025246.24269-5-han.xu@nxp.com
parent 10915857

drivers/mtd/nand/raw/gpmi-nand/gpmi-nand.c

+29 −23
Original line number Diff line number Diff line
@@ -218,7 +218,8 @@ static void gpmi_dump_info(struct gpmi_nand_data *this) 
		"ECC Strength           : %u\n"

		"Page Size in Bytes     : %u\n"

		"Metadata Size in Bytes : %u\n"

		"ECC Chunk Size in Bytes: %u\n"

		"ECC0 Chunk Size in Bytes: %u\n"

		"ECCn Chunk Size in Bytes: %u\n"

		"ECC Chunk Count        : %u\n"

		"Payload Size in Bytes  : %u\n"

		"Auxiliary Size in Bytes: %u\n"
@@ -229,7 +230,8 @@ static void gpmi_dump_info(struct gpmi_nand_data *this) 
		geo->ecc_strength,

		geo->page_size,

		geo->metadata_size,

		geo->ecc_chunk_size,

		geo->ecc0_chunk_size,

		geo->eccn_chunk_size,

		geo->ecc_chunk_count,

		geo->payload_size,

		geo->auxiliary_size,
@@ -293,13 +295,14 @@ static int set_geometry_by_ecc_info(struct gpmi_nand_data *this, 
			nanddev_get_ecc_requirements(&chip->base)->step_size);

		return -EINVAL;

	}

	geo->ecc_chunk_size = ecc_step;

	geo->ecc0_chunk_size = ecc_step;

	geo->eccn_chunk_size = ecc_step;

	geo->ecc_strength = round_up(ecc_strength, 2);

	if (!gpmi_check_ecc(this))

		return -EINVAL;



	/* Keep the C >= O */

	if (geo->ecc_chunk_size < mtd->oobsize) {

	if (geo->eccn_chunk_size < mtd->oobsize) {

		dev_err(this->dev,

			"unsupported nand chip. ecc size: %d, oob size : %d\n",

			ecc_step, mtd->oobsize);
@@ -309,7 +312,7 @@ static int set_geometry_by_ecc_info(struct gpmi_nand_data *this, 
	/* The default value, see comment in the legacy_set_geometry(). */

	geo->metadata_size = 10;



	geo->ecc_chunk_count = mtd->writesize / geo->ecc_chunk_size;

	geo->ecc_chunk_count = mtd->writesize / geo->eccn_chunk_size;



	/*

	 * Now, the NAND chip with 2K page(data chunk is 512byte) shows below:
@@ -431,13 +434,15 @@ static int legacy_set_geometry(struct gpmi_nand_data *this) 
	geo->gf_len = 13;



	/* The default for chunk size. */

	geo->ecc_chunk_size = 512;

	while (geo->ecc_chunk_size < mtd->oobsize) {

		geo->ecc_chunk_size *= 2; /* keep C >= O */

	geo->ecc0_chunk_size = 512;

	geo->eccn_chunk_size = 512;

	while (geo->eccn_chunk_size < mtd->oobsize) {

		geo->ecc0_chunk_size *= 2; /* keep C >= O */

		geo->eccn_chunk_size *= 2; /* keep C >= O */

		geo->gf_len = 14;

	}



	geo->ecc_chunk_count = mtd->writesize / geo->ecc_chunk_size;

	geo->ecc_chunk_count = mtd->writesize / geo->eccn_chunk_size;



	/* We use the same ECC strength for all chunks. */

	geo->ecc_strength = get_ecc_strength(this);
@@ -864,7 +869,7 @@ static int gpmi_raw_len_to_len(struct gpmi_nand_data *this, int raw_len) 
	 * we are passed in exec_op. Calculate the data length from it.

	 */

	if (this->bch)

		return ALIGN_DOWN(raw_len, this->bch_geometry.ecc_chunk_size);

		return ALIGN_DOWN(raw_len, this->bch_geometry.eccn_chunk_size);

	else

		return raw_len;

}
@@ -1256,7 +1261,7 @@ static int gpmi_count_bitflips(struct nand_chip *chip, void *buf, int first, 


			/* Read ECC bytes into our internal raw_buffer */

			offset = nfc_geo->metadata_size * 8;

			offset += ((8 * nfc_geo->ecc_chunk_size) + eccbits) * (i + 1);

			offset += ((8 * nfc_geo->eccn_chunk_size) + eccbits) * (i + 1);

			offset -= eccbits;

			bitoffset = offset % 8;

			eccbytes = DIV_ROUND_UP(offset + eccbits, 8);
@@ -1293,16 +1298,16 @@ static int gpmi_count_bitflips(struct nand_chip *chip, void *buf, int first, 
			if (i == 0) {

				/* The first block includes metadata */

				flips = nand_check_erased_ecc_chunk(

						buf + i * nfc_geo->ecc_chunk_size,

						nfc_geo->ecc_chunk_size,

						buf + i * nfc_geo->eccn_chunk_size,

						nfc_geo->eccn_chunk_size,

						eccbuf, eccbytes,

						this->auxiliary_virt,

						nfc_geo->metadata_size,

						nfc_geo->ecc_strength);

			} else {

				flips = nand_check_erased_ecc_chunk(

						buf + i * nfc_geo->ecc_chunk_size,

						nfc_geo->ecc_chunk_size,

						buf + i * nfc_geo->eccn_chunk_size,

						nfc_geo->eccn_chunk_size,

						eccbuf, eccbytes,

						NULL, 0,

						nfc_geo->ecc_strength);
@@ -1331,20 +1336,21 @@ static void gpmi_bch_layout_std(struct gpmi_nand_data *this) 
	struct bch_geometry *geo = &this->bch_geometry;

	unsigned int ecc_strength = geo->ecc_strength >> 1;

	unsigned int gf_len = geo->gf_len;

	unsigned int block_size = geo->ecc_chunk_size;

	unsigned int block0_size = geo->ecc0_chunk_size;

	unsigned int blockn_size = geo->eccn_chunk_size;



	this->bch_flashlayout0 =

		BF_BCH_FLASH0LAYOUT0_NBLOCKS(geo->ecc_chunk_count - 1) |

		BF_BCH_FLASH0LAYOUT0_META_SIZE(geo->metadata_size) |

		BF_BCH_FLASH0LAYOUT0_ECC0(ecc_strength, this) |

		BF_BCH_FLASH0LAYOUT0_GF(gf_len, this) |

		BF_BCH_FLASH0LAYOUT0_DATA0_SIZE(block_size, this);

		BF_BCH_FLASH0LAYOUT0_DATA0_SIZE(block0_size, this);



	this->bch_flashlayout1 =

		BF_BCH_FLASH0LAYOUT1_PAGE_SIZE(geo->page_size) |

		BF_BCH_FLASH0LAYOUT1_ECCN(ecc_strength, this) |

		BF_BCH_FLASH0LAYOUT1_GF(gf_len, this) |

		BF_BCH_FLASH0LAYOUT1_DATAN_SIZE(block_size, this);

		BF_BCH_FLASH0LAYOUT1_DATAN_SIZE(blockn_size, this);

}



static int gpmi_ecc_read_page(struct nand_chip *chip, uint8_t *buf,
@@ -1444,12 +1450,12 @@ static int gpmi_ecc_read_subpage(struct nand_chip *chip, uint32_t offs, 
		BF_BCH_FLASH0LAYOUT0_META_SIZE(meta) |

		BF_BCH_FLASH0LAYOUT0_ECC0(ecc_strength, this) |

		BF_BCH_FLASH0LAYOUT0_GF(geo->gf_len, this) |

		BF_BCH_FLASH0LAYOUT0_DATA0_SIZE(geo->ecc_chunk_size, this);

		BF_BCH_FLASH0LAYOUT0_DATA0_SIZE(geo->eccn_chunk_size, this);



	this->bch_flashlayout1 = BF_BCH_FLASH0LAYOUT1_PAGE_SIZE(page_size) |

		BF_BCH_FLASH0LAYOUT1_ECCN(ecc_strength, this) |

		BF_BCH_FLASH0LAYOUT1_GF(geo->gf_len, this) |

		BF_BCH_FLASH0LAYOUT1_DATAN_SIZE(geo->ecc_chunk_size, this);

		BF_BCH_FLASH0LAYOUT1_DATAN_SIZE(geo->eccn_chunk_size, this);



	this->bch = true;
@@ -1618,7 +1624,7 @@ static int gpmi_ecc_read_page_raw(struct nand_chip *chip, uint8_t *buf, 
	struct mtd_info *mtd = nand_to_mtd(chip);

	struct gpmi_nand_data *this = nand_get_controller_data(chip);

	struct bch_geometry *nfc_geo = &this->bch_geometry;

	int eccsize = nfc_geo->ecc_chunk_size;

	int eccsize = nfc_geo->eccn_chunk_size;

	int eccbits = nfc_geo->ecc_strength * nfc_geo->gf_len;

	u8 *tmp_buf = this->raw_buffer;

	size_t src_bit_off;
@@ -1703,7 +1709,7 @@ static int gpmi_ecc_write_page_raw(struct nand_chip *chip, const uint8_t *buf, 
	struct mtd_info *mtd = nand_to_mtd(chip);

	struct gpmi_nand_data *this = nand_get_controller_data(chip);

	struct bch_geometry *nfc_geo = &this->bch_geometry;

	int eccsize = nfc_geo->ecc_chunk_size;

	int eccsize = nfc_geo->eccn_chunk_size;

	int eccbits = nfc_geo->ecc_strength * nfc_geo->gf_len;

	u8 *tmp_buf = this->raw_buffer;

	uint8_t *oob = chip->oob_poi;
@@ -2077,7 +2083,7 @@ static int gpmi_init_last(struct gpmi_nand_data *this) 
	ecc->read_oob_raw = gpmi_ecc_read_oob_raw;

	ecc->write_oob_raw = gpmi_ecc_write_oob_raw;

	ecc->engine_type = NAND_ECC_ENGINE_TYPE_ON_HOST;

	ecc->size	= bch_geo->ecc_chunk_size;

	ecc->size	= bch_geo->eccn_chunk_size;

	ecc->strength	= bch_geo->ecc_strength;

	mtd_set_ooblayout(mtd, &gpmi_ooblayout_ops);

drivers/mtd/nand/raw/gpmi-nand/gpmi-nand.h

+5 −4
Original line number Diff line number Diff line
@@ -30,9 +30,9 @@ struct resources { 
 * @page_size:                The size, in bytes, of a physical page, including

 *                            both data and OOB.

 * @metadata_size:            The size, in bytes, of the metadata.

 * @ecc_chunk_size:           The size, in bytes, of a single ECC chunk. Note

 *                            the first chunk in the page includes both data and

 *                            metadata, so it's a bit larger than this value.

 * @ecc0_chunk_size:          The size, in bytes, of a first ECC chunk.

 * @eccn_chunk_size:          The size, in bytes, of a single ECC chunk after

 *                            the first chunk in the page.

 * @ecc_chunk_count:          The number of ECC chunks in the page,

 * @payload_size:             The size, in bytes, of the payload buffer.

 * @auxiliary_size:           The size, in bytes, of the auxiliary buffer.
@@ -48,7 +48,8 @@ struct bch_geometry { 
	unsigned int  ecc_strength;

	unsigned int  page_size;

	unsigned int  metadata_size;

	unsigned int  ecc_chunk_size;

	unsigned int  ecc0_chunk_size;

	unsigned int  eccn_chunk_size;

	unsigned int  ecc_chunk_count;

	unsigned int  payload_size;

	unsigned int  auxiliary_size;