mtd: nand: Add helpers to manage ECC engines and configurations

Add the logic in the NAND core to find the right ECC engine depending
on the NAND chip requirements and the user desires. Right now, the
choice may be made between (more will come):
* software Hamming
* software BCH
* on-die (SPI-NAND devices only)

Once the ECC engine has been found, the ECC engine must be
configured.

Signed-off-by: Miquel Raynal <miquel.raynal@bootlin.com>
Link: https://lore.kernel.org/linux-mtd/20201001102014.20100-2-miquel.raynal@bootlin.com

diff --git a/drivers/mtd/nand/core.c b/drivers/mtd/nand/core.c
index b6de955ac8bf106d3e9e9c4438ff96e36a9ec183..5e13a03d2b32f69b9a2a149caf2a7c7fcf59e824 100644 (file)
--- a/drivers/mtd/nand/core.c
+++ b/drivers/mtd/nand/core.c
@@ -207,6 +207,130 @@ int nanddev_mtd_max_bad_blocks(struct mtd_info *mtd, loff_t offs, size_t len)
 }
 EXPORT_SYMBOL_GPL(nanddev_mtd_max_bad_blocks);
 
+/**
+ * nanddev_get_ecc_engine() - Find and get a suitable ECC engine
+ * @nand: NAND device
+ */
+static int nanddev_get_ecc_engine(struct nand_device *nand)
+{
+       int engine_type;
+
+       /* Read the user desires in terms of ECC engine/configuration */
+       of_get_nand_ecc_user_config(nand);
+
+       engine_type = nand->ecc.user_conf.engine_type;
+       if (engine_type == NAND_ECC_ENGINE_TYPE_INVALID)
+               engine_type = nand->ecc.defaults.engine_type;
+
+       switch (engine_type) {
+       case NAND_ECC_ENGINE_TYPE_NONE:
+               return 0;
+       case NAND_ECC_ENGINE_TYPE_SOFT:
+               nand->ecc.engine = nand_ecc_get_sw_engine(nand);
+               break;
+       case NAND_ECC_ENGINE_TYPE_ON_DIE:
+               nand->ecc.engine = nand_ecc_get_on_die_hw_engine(nand);
+               break;
+       case NAND_ECC_ENGINE_TYPE_ON_HOST:
+               pr_err("On-host hardware ECC engines not supported yet\n");
+               break;
+       default:
+               pr_err("Missing ECC engine type\n");
+       }
+
+       if (!nand->ecc.engine)
+               return  -EINVAL;
+
+       return 0;
+}
+
+/**
+ * nanddev_put_ecc_engine() - Dettach and put the in-use ECC engine
+ * @nand: NAND device
+ */
+static int nanddev_put_ecc_engine(struct nand_device *nand)
+{
+       switch (nand->ecc.ctx.conf.engine_type) {
+       case NAND_ECC_ENGINE_TYPE_ON_HOST:
+               pr_err("On-host hardware ECC engines not supported yet\n");
+               break;
+       case NAND_ECC_ENGINE_TYPE_NONE:
+       case NAND_ECC_ENGINE_TYPE_SOFT:
+       case NAND_ECC_ENGINE_TYPE_ON_DIE:
+       default:
+               break;
+       }
+
+       return 0;
+}
+
+/**
+ * nanddev_find_ecc_configuration() - Find a suitable ECC configuration
+ * @nand: NAND device
+ */
+static int nanddev_find_ecc_configuration(struct nand_device *nand)
+{
+       int ret;
+
+       if (!nand->ecc.engine)
+               return -ENOTSUPP;
+
+       ret = nand_ecc_init_ctx(nand);
+       if (ret)
+               return ret;
+
+       if (!nand_ecc_is_strong_enough(nand))
+               pr_warn("WARNING: %s: the ECC used on your system is too weak compared to the one required by the NAND chip\n",
+                       nand->mtd.name);
+
+       return 0;
+}
+
+/**
+ * nanddev_ecc_engine_init() - Initialize an ECC engine for the chip
+ * @nand: NAND device
+ */
+int nanddev_ecc_engine_init(struct nand_device *nand)
+{
+       int ret;
+
+       /* Look for the ECC engine to use */
+       ret = nanddev_get_ecc_engine(nand);
+       if (ret) {
+               pr_err("No ECC engine found\n");
+               return ret;
+       }
+
+       /* No ECC engine requested */
+       if (!nand->ecc.engine)
+               return 0;
+
+       /* Configure the engine: balance user input and chip requirements */
+       ret = nanddev_find_ecc_configuration(nand);
+       if (ret) {
+               pr_err("No suitable ECC configuration\n");
+               nanddev_put_ecc_engine(nand);
+
+               return ret;
+       }
+
+       return 0;
+}
+EXPORT_SYMBOL_GPL(nanddev_ecc_engine_init);
+
+/**
+ * nanddev_ecc_engine_cleanup() - Cleanup ECC engine initializations
+ * @nand: NAND device
+ */
+void nanddev_ecc_engine_cleanup(struct nand_device *nand)
+{
+       if (nand->ecc.engine)
+               nand_ecc_cleanup_ctx(nand);
+
+       nanddev_put_ecc_engine(nand);
+}
+EXPORT_SYMBOL_GPL(nanddev_ecc_engine_cleanup);
+
 /**
  * nanddev_init() - Initialize a NAND device
  * @nand: NAND device

diff --git a/include/linux/mtd/nand.h b/include/linux/mtd/nand.h
index 6c6f91c03c42b38d80e37d6b851650909be36fc4..414f8a4d28538c04a197977d9d7bb5b9351534df 100644 (file)
--- a/include/linux/mtd/nand.h
+++ b/include/linux/mtd/nand.h
@@ -936,6 +936,10 @@ bool nanddev_isreserved(struct nand_device *nand, const struct nand_pos *pos);
 int nanddev_erase(struct nand_device *nand, const struct nand_pos *pos);
 int nanddev_markbad(struct nand_device *nand, const struct nand_pos *pos);
 
+/* ECC related functions */
+int nanddev_ecc_engine_init(struct nand_device *nand);
+void nanddev_ecc_engine_cleanup(struct nand_device *nand);
+
 /* BBT related functions */
 enum nand_bbt_block_status {
        NAND_BBT_BLOCK_STATUS_UNKNOWN,