Commit 35fe1b98 authored by Miquel Raynal's avatar Miquel Raynal
Browse files

mtd: nand: ecc-hamming: Create the software Hamming engine 



Let's continue introducing the generic ECC engine abstraction in the
NAND subsystem by instantiating a second ECC engine: software
Hamming.

Signed-off-by: default avatarMiquel Raynal <miquel.raynal@bootlin.com>
Link: https://lore.kernel.org/linux-mtd/20200929230124.31491-20-miquel.raynal@bootlin.com
parent 5180a62c

drivers/mtd/nand/ecc-sw-hamming.c

+193 −0
Original line number Diff line number Diff line
@@ -17,7 +17,9 @@ 
#include <linux/types.h>

#include <linux/kernel.h>

#include <linux/module.h>

#include <linux/mtd/nand.h>

#include <linux/mtd/nand-ecc-sw-hamming.h>

#include <linux/slab.h>

#include <asm/byteorder.h>



/*
@@ -460,6 +462,197 @@ int nand_ecc_sw_hamming_correct(struct nand_device *nand, unsigned char *buf, 
}

EXPORT_SYMBOL(nand_ecc_sw_hamming_correct);



int nand_ecc_sw_hamming_init_ctx(struct nand_device *nand)

{

	struct nand_ecc_props *conf = &nand->ecc.ctx.conf;

	struct nand_ecc_sw_hamming_conf *engine_conf;

	struct mtd_info *mtd = nanddev_to_mtd(nand);

	int ret;



	if (!mtd->ooblayout) {

		switch (mtd->oobsize) {

		case 8:

		case 16:

			mtd_set_ooblayout(mtd, nand_get_small_page_ooblayout());

			break;

		case 64:

		case 128:

			mtd_set_ooblayout(mtd,

					  nand_get_large_page_hamming_ooblayout());

			break;

		default:

			return -ENOTSUPP;

		}

	}



	conf->engine_type = NAND_ECC_ENGINE_TYPE_SOFT;

	conf->algo = NAND_ECC_ALGO_HAMMING;

	conf->step_size = nand->ecc.user_conf.step_size;

	conf->strength = 1;



	/* Use the strongest configuration by default */

	if (conf->step_size != 256 && conf->step_size != 512)

		conf->step_size = 256;



	engine_conf = kzalloc(sizeof(*engine_conf), GFP_KERNEL);

	if (!engine_conf)

		return -ENOMEM;



	ret = nand_ecc_init_req_tweaking(&engine_conf->req_ctx, nand);

	if (ret)

		goto free_engine_conf;



	engine_conf->code_size = 3;

	engine_conf->nsteps = mtd->writesize / conf->step_size;

	engine_conf->calc_buf = kzalloc(mtd->oobsize, GFP_KERNEL);

	engine_conf->code_buf = kzalloc(mtd->oobsize, GFP_KERNEL);

	if (!engine_conf->calc_buf || !engine_conf->code_buf) {

		ret = -ENOMEM;

		goto free_bufs;

	}



	nand->ecc.ctx.priv = engine_conf;

	nand->ecc.ctx.total = engine_conf->nsteps * engine_conf->code_size;



	return 0;



free_bufs:

	nand_ecc_cleanup_req_tweaking(&engine_conf->req_ctx);

	kfree(engine_conf->calc_buf);

	kfree(engine_conf->code_buf);

free_engine_conf:

	kfree(engine_conf);



	return ret;

}

EXPORT_SYMBOL(nand_ecc_sw_hamming_init_ctx);



void nand_ecc_sw_hamming_cleanup_ctx(struct nand_device *nand)

{

	struct nand_ecc_sw_hamming_conf *engine_conf = nand->ecc.ctx.priv;



	if (engine_conf) {

		nand_ecc_cleanup_req_tweaking(&engine_conf->req_ctx);

		kfree(engine_conf->calc_buf);

		kfree(engine_conf->code_buf);

		kfree(engine_conf);

	}

}

EXPORT_SYMBOL(nand_ecc_sw_hamming_cleanup_ctx);



static int nand_ecc_sw_hamming_prepare_io_req(struct nand_device *nand,

					      struct nand_page_io_req *req)

{

	struct nand_ecc_sw_hamming_conf *engine_conf = nand->ecc.ctx.priv;

	struct mtd_info *mtd = nanddev_to_mtd(nand);

	int eccsize = nand->ecc.ctx.conf.step_size;

	int eccbytes = engine_conf->code_size;

	int eccsteps = engine_conf->nsteps;

	int total = nand->ecc.ctx.total;

	u8 *ecccalc = engine_conf->calc_buf;

	const u8 *data;

	int i;



	/* Nothing to do for a raw operation */

	if (req->mode == MTD_OPS_RAW)

		return 0;



	/* This engine does not provide BBM/free OOB bytes protection */

	if (!req->datalen)

		return 0;



	nand_ecc_tweak_req(&engine_conf->req_ctx, req);



	/* No more preparation for page read */

	if (req->type == NAND_PAGE_READ)

		return 0;



	/* Preparation for page write: derive the ECC bytes and place them */

	for (i = 0, data = req->databuf.out;

	     eccsteps;

	     eccsteps--, i += eccbytes, data += eccsize)

		nand_ecc_sw_hamming_calculate(nand, data, &ecccalc[i]);



	return mtd_ooblayout_set_eccbytes(mtd, ecccalc, (void *)req->oobbuf.out,

					  0, total);

}



static int nand_ecc_sw_hamming_finish_io_req(struct nand_device *nand,

					     struct nand_page_io_req *req)

{

	struct nand_ecc_sw_hamming_conf *engine_conf = nand->ecc.ctx.priv;

	struct mtd_info *mtd = nanddev_to_mtd(nand);

	int eccsize = nand->ecc.ctx.conf.step_size;

	int total = nand->ecc.ctx.total;

	int eccbytes = engine_conf->code_size;

	int eccsteps = engine_conf->nsteps;

	u8 *ecccalc = engine_conf->calc_buf;

	u8 *ecccode = engine_conf->code_buf;

	unsigned int max_bitflips = 0;

	u8 *data = req->databuf.in;

	int i, ret;



	/* Nothing to do for a raw operation */

	if (req->mode == MTD_OPS_RAW)

		return 0;



	/* This engine does not provide BBM/free OOB bytes protection */

	if (!req->datalen)

		return 0;



	/* No more preparation for page write */

	if (req->type == NAND_PAGE_WRITE) {

		nand_ecc_restore_req(&engine_conf->req_ctx, req);

		return 0;

	}



	/* Finish a page read: retrieve the (raw) ECC bytes*/

	ret = mtd_ooblayout_get_eccbytes(mtd, ecccode, req->oobbuf.in, 0,

					 total);

	if (ret)

		return ret;



	/* Calculate the ECC bytes */

	for (i = 0; eccsteps; eccsteps--, i += eccbytes, data += eccsize)

		nand_ecc_sw_hamming_calculate(nand, data, &ecccalc[i]);



	/* Finish a page read: compare and correct */

	for (eccsteps = engine_conf->nsteps, i = 0, data = req->databuf.in;

	     eccsteps;

	     eccsteps--, i += eccbytes, data += eccsize) {

		int stat =  nand_ecc_sw_hamming_correct(nand, data,

							&ecccode[i],

							&ecccalc[i]);

		if (stat < 0) {

			mtd->ecc_stats.failed++;

		} else {

			mtd->ecc_stats.corrected += stat;

			max_bitflips = max_t(unsigned int, max_bitflips, stat);

		}

	}



	nand_ecc_restore_req(&engine_conf->req_ctx, req);



	return max_bitflips;

}



static struct nand_ecc_engine_ops nand_ecc_sw_hamming_engine_ops = {

	.init_ctx = nand_ecc_sw_hamming_init_ctx,

	.cleanup_ctx = nand_ecc_sw_hamming_cleanup_ctx,

	.prepare_io_req = nand_ecc_sw_hamming_prepare_io_req,

	.finish_io_req = nand_ecc_sw_hamming_finish_io_req,

};



static struct nand_ecc_engine nand_ecc_sw_hamming_engine = {

	.ops = &nand_ecc_sw_hamming_engine_ops,

};



struct nand_ecc_engine *nand_ecc_sw_hamming_get_engine(void)

{

	return &nand_ecc_sw_hamming_engine;

}

EXPORT_SYMBOL(nand_ecc_sw_hamming_get_engine);



MODULE_LICENSE("GPL");

MODULE_AUTHOR("Frans Meulenbroeks <fransmeulenbroeks@gmail.com>");

MODULE_DESCRIPTION("NAND software Hamming ECC support");

drivers/mtd/nand/raw/nand_base.c

+9 −17
Original line number Diff line number Diff line
@@ -5141,34 +5141,24 @@ static void nand_scan_ident_cleanup(struct nand_chip *chip) 


int rawnand_sw_hamming_init(struct nand_chip *chip)

{

	struct mtd_info *mtd = nand_to_mtd(chip);

	struct nand_ecc_sw_hamming_conf *engine_conf;

	struct nand_device *base = &chip->base;

	int ret;



	base->ecc.user_conf.engine_type = NAND_ECC_ENGINE_TYPE_SOFT;

	base->ecc.user_conf.algo = NAND_ECC_ALGO_HAMMING;

	base->ecc.user_conf.strength = chip->ecc.strength;

	base->ecc.user_conf.step_size = chip->ecc.size;



	if (base->ecc.user_conf.strength != 1 ||

	    (base->ecc.user_conf.step_size != 256 &&

	     base->ecc.user_conf.step_size != 512)) {

		pr_err("%s: unsupported strength or step size\n", __func__);

		return -EINVAL;

	}



	engine_conf = kzalloc(sizeof(*engine_conf), GFP_KERNEL);

	if (!engine_conf)

		return -ENOMEM;

	ret = nand_ecc_sw_hamming_init_ctx(base);

	if (ret)

		return ret;



	engine_conf->code_size = 3;

	engine_conf->nsteps = mtd->writesize / base->ecc.user_conf.step_size;

	engine_conf = base->ecc.ctx.priv;



	if (chip->ecc.options & NAND_ECC_SOFT_HAMMING_SM_ORDER)

		engine_conf->sm_order = true;



	base->ecc.ctx.priv = engine_conf;



	chip->ecc.size = base->ecc.ctx.conf.step_size;

	chip->ecc.strength = base->ecc.ctx.conf.strength;

	chip->ecc.total = base->ecc.ctx.total;
@@ -5204,7 +5194,7 @@ void rawnand_sw_hamming_cleanup(struct nand_chip *chip) 
{

	struct nand_device *base = &chip->base;



	kfree(base->ecc.ctx.priv);

	nand_ecc_sw_hamming_cleanup_ctx(base);

}

EXPORT_SYMBOL(rawnand_sw_hamming_cleanup);
@@ -5733,7 +5723,9 @@ static int nand_scan_tail(struct nand_chip *chip) 
	 */

	if (!mtd->ooblayout &&

	    !(ecc->engine_type == NAND_ECC_ENGINE_TYPE_SOFT &&

	      ecc->algo == NAND_ECC_ALGO_BCH)) {

	      ecc->algo == NAND_ECC_ALGO_BCH) &&

	    !(ecc->engine_type == NAND_ECC_ENGINE_TYPE_SOFT &&

	      ecc->algo == NAND_ECC_ALGO_HAMMING)) {

		switch (mtd->oobsize) {

		case 8:

		case 16:

include/linux/mtd/nand-ecc-sw-hamming.h

+12 −4
Original line number Diff line number Diff line
@@ -14,8 +14,8 @@ 


/**

 * struct nand_ecc_sw_hamming_conf - private software Hamming ECC engine structure

 * @reqooblen: Save the actual user OOB length requested before overwriting it

 * @spare_oobbuf: Spare OOB buffer if none is provided

 * @req_ctx: Save request context and tweak the original request to fit the

 *           engine needs

 * @code_size: Number of bytes needed to store a code (one code per step)

 * @nsteps: Number of steps

 * @calc_buf: Buffer to use when calculating ECC bytes
@@ -23,8 +23,7 @@ 
 * @sm_order: Smart Media special ordering

 */

struct nand_ecc_sw_hamming_conf {

	unsigned int reqooblen;

	void *spare_oobbuf;

	struct nand_ecc_req_tweak_ctx req_ctx;

	unsigned int code_size;

	unsigned int nsteps;

	u8 *calc_buf;
@@ -34,6 +33,8 @@ struct nand_ecc_sw_hamming_conf { 


#if IS_ENABLED(CONFIG_MTD_NAND_ECC_SW_HAMMING)



int nand_ecc_sw_hamming_init_ctx(struct nand_device *nand);

void nand_ecc_sw_hamming_cleanup_ctx(struct nand_device *nand);

int ecc_sw_hamming_calculate(const unsigned char *buf, unsigned int step_size,

			     unsigned char *code, bool sm_order);

int nand_ecc_sw_hamming_calculate(struct nand_device *nand,
@@ -48,6 +49,13 @@ int nand_ecc_sw_hamming_correct(struct nand_device *nand, unsigned char *buf, 


#else /* !CONFIG_MTD_NAND_ECC_SW_HAMMING */



static inline int nand_ecc_sw_hamming_init_ctx(struct nand_device *nand)

{

	return -ENOTSUPP;

}



static inline void nand_ecc_sw_hamming_cleanup_ctx(struct nand_device *nand) {}



static inline int ecc_sw_hamming_calculate(const unsigned char *buf,

					   unsigned int step_size,

					   unsigned char *code, bool sm_order)

include/linux/mtd/nand.h

+9 −0
Original line number Diff line number Diff line
@@ -278,6 +278,15 @@ int nand_ecc_finish_io_req(struct nand_device *nand, 
			   struct nand_page_io_req *req);

bool nand_ecc_is_strong_enough(struct nand_device *nand);



#if IS_ENABLED(CONFIG_MTD_NAND_ECC_SW_HAMMING)

struct nand_ecc_engine *nand_ecc_sw_hamming_get_engine(void);

#else

static inline struct nand_ecc_engine *nand_ecc_sw_hamming_get_engine(void)

{

	return NULL;

}

#endif /* CONFIG_MTD_NAND_ECC_SW_HAMMING */



#if IS_ENABLED(CONFIG_MTD_NAND_ECC_SW_BCH)

struct nand_ecc_engine *nand_ecc_sw_bch_get_engine(void);

#else