mirror of https://gitee.com/openkylin/linux.git
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: Miquel Raynal <miquel.raynal@bootlin.com> Link: https://lore.kernel.org/linux-mtd/20200929230124.31491-20-miquel.raynal@bootlin.com
This commit is contained in:
Miquel Raynal
parent
5180a62c12
commit
35fe1b98a0
|
|
@ -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");
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
ret = nand_ecc_sw_hamming_init_ctx(base);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
engine_conf = kzalloc(sizeof(*engine_conf), GFP_KERNEL);
|
||||
if (!engine_conf)
|
||||
return -ENOMEM;
|
||||
|
||||
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:
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
Loading…
Reference in New Issue