Lines Matching +full:nand +full:- +full:no +full:- +full:ecc +full:- +full:engine
1 // SPDX-License-Identifier: GPL-2.0+
3 * Generic Error-Correcting Code (ECC) engine
10 * This file describes the abstraction of any NAND ECC engine. It has been
11 * designed to fit most cases, including parallel NANDs and SPI-NANDs.
13 * There are three main situations where instantiating this ECC engine makes
15 * - external: The ECC engine is outside the NAND pipeline, typically this
16 * is a software ECC engine, or an hardware engine that is
17 * outside the NAND controller pipeline.
18 * - pipelined: The ECC engine is inside the NAND pipeline, ie. on the
19 * controller's side. This is the case of most of the raw NAND
20 * controllers. In the pipeline case, the ECC bytes are
23 * - ondie: The ECC engine is inside the NAND pipeline, on the chip's side.
24 * Some NAND chips can correct themselves the data.
28 * - prepare: Prepare an I/O request. Enable/disable the ECC engine based on
30 * engine, this step may involve to derive the ECC bytes and place
32 * - finish: Finish an I/O request. Correct the data in case of a read
35 * hardware specific stuff to do, like shutting down the engine to
40 * - raw: Correction disabled
41 * - ecc: Correction enabled
44 * - read: Load data from the NAND chip
45 * - write: Store data in the NAND chip
51 * [external ECC engine]
52 * - external + prepare + raw + read: do nothing
53 * - external + finish + raw + read: do nothing
54 * - external + prepare + raw + write: do nothing
55 * - external + finish + raw + write: do nothing
56 * - external + prepare + ecc + read: do nothing
57 * - external + finish + ecc + read: calculate expected ECC bytes, extract
58 * ECC bytes from OOB buffer, correct
60 * - external + prepare + ecc + write: calculate ECC bytes and store them at
63 * - external + finish + ecc + write: do nothing
65 * [pipelined ECC engine]
66 * - pipelined + prepare + raw + read: disable the controller's ECC engine if
68 * - pipelined + finish + raw + read: do nothing
69 * - pipelined + prepare + raw + write: disable the controller's ECC engine if
71 * - pipelined + finish + raw + write: do nothing
72 * - pipelined + prepare + ecc + read: enable the controller's ECC engine if
74 * - pipelined + finish + ecc + read: check the status, report any
76 * - pipelined + prepare + ecc + write: enable the controller's ECC engine if
78 * - pipelined + finish + ecc + write: do nothing
80 * [ondie ECC engine]
81 * - ondie + prepare + raw + read: send commands to disable the on-chip ECC
82 * engine if activated
83 * - ondie + finish + raw + read: do nothing
84 * - ondie + prepare + raw + write: send commands to disable the on-chip ECC
85 * engine if activated
86 * - ondie + finish + raw + write: do nothing
87 * - ondie + prepare + ecc + read: send commands to enable the on-chip ECC
88 * engine if deactivated
89 * - ondie + finish + ecc + read: send commands to check the status, report
91 * - ondie + prepare + ecc + write: send commands to enable the on-chip ECC
92 * engine if deactivated
93 * - ondie + finish + ecc + write: do nothing
97 #include <linux/mtd/nand.h>
101 * nand_ecc_init_ctx - Init the ECC engine context
102 * @nand: the NAND device
106 int nand_ecc_init_ctx(struct nand_device *nand) in nand_ecc_init_ctx() argument
108 if (!nand->ecc.engine || !nand->ecc.engine->ops->init_ctx) in nand_ecc_init_ctx()
111 return nand->ecc.engine->ops->init_ctx(nand); in nand_ecc_init_ctx()
116 * nand_ecc_cleanup_ctx - Cleanup the ECC engine context
117 * @nand: the NAND device
119 void nand_ecc_cleanup_ctx(struct nand_device *nand) in nand_ecc_cleanup_ctx() argument
121 if (nand->ecc.engine && nand->ecc.engine->ops->cleanup_ctx) in nand_ecc_cleanup_ctx()
122 nand->ecc.engine->ops->cleanup_ctx(nand); in nand_ecc_cleanup_ctx()
127 * nand_ecc_prepare_io_req - Prepare an I/O request
128 * @nand: the NAND device
131 int nand_ecc_prepare_io_req(struct nand_device *nand, in nand_ecc_prepare_io_req() argument
134 if (!nand->ecc.engine || !nand->ecc.engine->ops->prepare_io_req) in nand_ecc_prepare_io_req()
137 return nand->ecc.engine->ops->prepare_io_req(nand, req); in nand_ecc_prepare_io_req()
142 * nand_ecc_finish_io_req - Finish an I/O request
143 * @nand: the NAND device
146 int nand_ecc_finish_io_req(struct nand_device *nand, in nand_ecc_finish_io_req() argument
149 if (!nand->ecc.engine || !nand->ecc.engine->ops->finish_io_req) in nand_ecc_finish_io_req()
152 return nand->ecc.engine->ops->finish_io_req(nand, req); in nand_ecc_finish_io_req()
160 struct nand_device *nand = mtd_to_nanddev(mtd); in nand_ooblayout_ecc_sp() local
161 unsigned int total_ecc_bytes = nand->ecc.ctx.total; in nand_ooblayout_ecc_sp()
164 return -ERANGE; in nand_ooblayout_ecc_sp()
167 oobregion->offset = 0; in nand_ooblayout_ecc_sp()
168 if (mtd->oobsize == 16) in nand_ooblayout_ecc_sp()
169 oobregion->length = 4; in nand_ooblayout_ecc_sp()
171 oobregion->length = 3; in nand_ooblayout_ecc_sp()
173 if (mtd->oobsize == 8) in nand_ooblayout_ecc_sp()
174 return -ERANGE; in nand_ooblayout_ecc_sp()
176 oobregion->offset = 6; in nand_ooblayout_ecc_sp()
177 oobregion->length = total_ecc_bytes - 4; in nand_ooblayout_ecc_sp()
187 return -ERANGE; in nand_ooblayout_free_sp()
189 if (mtd->oobsize == 16) { in nand_ooblayout_free_sp()
191 return -ERANGE; in nand_ooblayout_free_sp()
193 oobregion->length = 8; in nand_ooblayout_free_sp()
194 oobregion->offset = 8; in nand_ooblayout_free_sp()
196 oobregion->length = 2; in nand_ooblayout_free_sp()
198 oobregion->offset = 3; in nand_ooblayout_free_sp()
200 oobregion->offset = 6; in nand_ooblayout_free_sp()
207 .ecc = nand_ooblayout_ecc_sp,
220 struct nand_device *nand = mtd_to_nanddev(mtd); in nand_ooblayout_ecc_lp() local
221 unsigned int total_ecc_bytes = nand->ecc.ctx.total; in nand_ooblayout_ecc_lp()
224 return -ERANGE; in nand_ooblayout_ecc_lp()
226 oobregion->length = total_ecc_bytes; in nand_ooblayout_ecc_lp()
227 oobregion->offset = mtd->oobsize - oobregion->length; in nand_ooblayout_ecc_lp()
235 struct nand_device *nand = mtd_to_nanddev(mtd); in nand_ooblayout_free_lp() local
236 unsigned int total_ecc_bytes = nand->ecc.ctx.total; in nand_ooblayout_free_lp()
239 return -ERANGE; in nand_ooblayout_free_lp()
241 oobregion->length = mtd->oobsize - total_ecc_bytes - 2; in nand_ooblayout_free_lp()
242 oobregion->offset = 2; in nand_ooblayout_free_lp()
248 .ecc = nand_ooblayout_ecc_lp,
259 * Support the old "large page" layout used for 1-bit Hamming ECC where ECC
265 struct nand_device *nand = mtd_to_nanddev(mtd); in nand_ooblayout_ecc_lp_hamming() local
266 unsigned int total_ecc_bytes = nand->ecc.ctx.total; in nand_ooblayout_ecc_lp_hamming()
269 return -ERANGE; in nand_ooblayout_ecc_lp_hamming()
271 switch (mtd->oobsize) { in nand_ooblayout_ecc_lp_hamming()
273 oobregion->offset = 40; in nand_ooblayout_ecc_lp_hamming()
276 oobregion->offset = 80; in nand_ooblayout_ecc_lp_hamming()
279 return -EINVAL; in nand_ooblayout_ecc_lp_hamming()
282 oobregion->length = total_ecc_bytes; in nand_ooblayout_ecc_lp_hamming()
283 if (oobregion->offset + oobregion->length > mtd->oobsize) in nand_ooblayout_ecc_lp_hamming()
284 return -ERANGE; in nand_ooblayout_ecc_lp_hamming()
292 struct nand_device *nand = mtd_to_nanddev(mtd); in nand_ooblayout_free_lp_hamming() local
293 unsigned int total_ecc_bytes = nand->ecc.ctx.total; in nand_ooblayout_free_lp_hamming()
297 return -ERANGE; in nand_ooblayout_free_lp_hamming()
299 switch (mtd->oobsize) { in nand_ooblayout_free_lp_hamming()
307 return -EINVAL; in nand_ooblayout_free_lp_hamming()
311 oobregion->offset = 2; in nand_ooblayout_free_lp_hamming()
312 oobregion->length = ecc_offset - 2; in nand_ooblayout_free_lp_hamming()
314 oobregion->offset = ecc_offset + total_ecc_bytes; in nand_ooblayout_free_lp_hamming()
315 oobregion->length = mtd->oobsize - oobregion->offset; in nand_ooblayout_free_lp_hamming()
322 .ecc = nand_ooblayout_ecc_lp_hamming,
337 if (of_property_read_bool(np, "nand-no-ecc-engine")) in of_get_nand_ecc_engine_type()
340 if (of_property_read_bool(np, "nand-use-soft-ecc-engine")) in of_get_nand_ecc_engine_type()
343 eng_np = of_parse_phandle(np, "nand-ecc-engine", 0); in of_get_nand_ecc_engine_type()
367 err = of_property_read_string(np, "nand-ecc-placement", &pm); in of_get_nand_ecc_placement()
391 err = of_property_read_string(np, "nand-ecc-algo", &pm); in of_get_nand_ecc_algo()
409 ret = of_property_read_u32(np, "nand-ecc-step-size", &val); in of_get_nand_ecc_step_size()
418 ret = of_property_read_u32(np, "nand-ecc-strength", &val); in of_get_nand_ecc_strength()
422 void of_get_nand_ecc_user_config(struct nand_device *nand) in of_get_nand_ecc_user_config() argument
424 struct device_node *dn = nanddev_get_of_node(nand); in of_get_nand_ecc_user_config()
427 nand->ecc.user_conf.engine_type = of_get_nand_ecc_engine_type(dn); in of_get_nand_ecc_user_config()
428 nand->ecc.user_conf.algo = of_get_nand_ecc_algo(dn); in of_get_nand_ecc_user_config()
429 nand->ecc.user_conf.placement = of_get_nand_ecc_placement(dn); in of_get_nand_ecc_user_config()
433 nand->ecc.user_conf.strength = strength; in of_get_nand_ecc_user_config()
437 nand->ecc.user_conf.step_size = size; in of_get_nand_ecc_user_config()
439 if (of_property_read_bool(dn, "nand-ecc-maximize")) in of_get_nand_ecc_user_config()
440 nand->ecc.user_conf.flags |= NAND_ECC_MAXIMIZE_STRENGTH; in of_get_nand_ecc_user_config()
445 * nand_ecc_is_strong_enough - Check if the chip configuration meets the
448 * @nand: Device to check
461 bool nand_ecc_is_strong_enough(struct nand_device *nand) in nand_ecc_is_strong_enough() argument
463 const struct nand_ecc_props *reqs = nanddev_get_ecc_requirements(nand); in nand_ecc_is_strong_enough()
464 const struct nand_ecc_props *conf = nanddev_get_ecc_conf(nand); in nand_ecc_is_strong_enough()
465 struct mtd_info *mtd = nanddev_to_mtd(nand); in nand_ecc_is_strong_enough()
468 if (conf->step_size == 0 || reqs->step_size == 0) in nand_ecc_is_strong_enough()
476 corr = (mtd->writesize * conf->strength) / conf->step_size; in nand_ecc_is_strong_enough()
477 ds_corr = (mtd->writesize * reqs->strength) / reqs->step_size; in nand_ecc_is_strong_enough()
479 return corr >= ds_corr && conf->strength >= reqs->strength; in nand_ecc_is_strong_enough()
483 /* ECC engine driver internal helpers */
485 struct nand_device *nand) in nand_ecc_init_req_tweaking() argument
489 ctx->nand = nand; in nand_ecc_init_req_tweaking()
492 if (!ctx->page_buffer_size) in nand_ecc_init_req_tweaking()
493 ctx->page_buffer_size = nanddev_page_size(nand); in nand_ecc_init_req_tweaking()
494 if (!ctx->oob_buffer_size) in nand_ecc_init_req_tweaking()
495 ctx->oob_buffer_size = nanddev_per_page_oobsize(nand); in nand_ecc_init_req_tweaking()
497 total_buffer_size = ctx->page_buffer_size + ctx->oob_buffer_size; in nand_ecc_init_req_tweaking()
499 ctx->spare_databuf = kzalloc(total_buffer_size, GFP_KERNEL); in nand_ecc_init_req_tweaking()
500 if (!ctx->spare_databuf) in nand_ecc_init_req_tweaking()
501 return -ENOMEM; in nand_ecc_init_req_tweaking()
503 ctx->spare_oobbuf = ctx->spare_databuf + ctx->page_buffer_size; in nand_ecc_init_req_tweaking()
511 kfree(ctx->spare_databuf); in nand_ecc_cleanup_req_tweaking()
522 struct nand_device *nand = ctx->nand; in nand_ecc_tweak_req() local
526 ctx->orig_req = *req; in nand_ecc_tweak_req()
527 ctx->bounce_data = false; in nand_ecc_tweak_req()
528 ctx->bounce_oob = false; in nand_ecc_tweak_req()
529 orig = &ctx->orig_req; in nand_ecc_tweak_req()
533 if (orig->datalen < nanddev_page_size(nand)) { in nand_ecc_tweak_req()
534 ctx->bounce_data = true; in nand_ecc_tweak_req()
535 tweak->dataoffs = 0; in nand_ecc_tweak_req()
536 tweak->datalen = nanddev_page_size(nand); in nand_ecc_tweak_req()
537 tweak->databuf.in = ctx->spare_databuf; in nand_ecc_tweak_req()
538 memset(tweak->databuf.in, 0xFF, ctx->page_buffer_size); in nand_ecc_tweak_req()
541 if (orig->ooblen < nanddev_per_page_oobsize(nand)) { in nand_ecc_tweak_req()
542 ctx->bounce_oob = true; in nand_ecc_tweak_req()
543 tweak->ooboffs = 0; in nand_ecc_tweak_req()
544 tweak->ooblen = nanddev_per_page_oobsize(nand); in nand_ecc_tweak_req()
545 tweak->oobbuf.in = ctx->spare_oobbuf; in nand_ecc_tweak_req()
546 memset(tweak->oobbuf.in, 0xFF, ctx->oob_buffer_size); in nand_ecc_tweak_req()
550 if (orig->type == NAND_PAGE_WRITE) { in nand_ecc_tweak_req()
551 if (ctx->bounce_data) in nand_ecc_tweak_req()
552 memcpy((void *)tweak->databuf.out + orig->dataoffs, in nand_ecc_tweak_req()
553 orig->databuf.out, orig->datalen); in nand_ecc_tweak_req()
555 if (ctx->bounce_oob) in nand_ecc_tweak_req()
556 memcpy((void *)tweak->oobbuf.out + orig->ooboffs, in nand_ecc_tweak_req()
557 orig->oobbuf.out, orig->ooblen); in nand_ecc_tweak_req()
567 orig = &ctx->orig_req; in nand_ecc_restore_req()
571 if (orig->type == NAND_PAGE_READ) { in nand_ecc_restore_req()
572 if (ctx->bounce_data) in nand_ecc_restore_req()
573 memcpy(orig->databuf.in, in nand_ecc_restore_req()
574 tweak->databuf.in + orig->dataoffs, in nand_ecc_restore_req()
575 orig->datalen); in nand_ecc_restore_req()
577 if (ctx->bounce_oob) in nand_ecc_restore_req()
578 memcpy(orig->oobbuf.in, in nand_ecc_restore_req()
579 tweak->oobbuf.in + orig->ooboffs, in nand_ecc_restore_req()
580 orig->ooblen); in nand_ecc_restore_req()
588 struct nand_ecc_engine *nand_ecc_get_sw_engine(struct nand_device *nand) in nand_ecc_get_sw_engine() argument
590 unsigned int algo = nand->ecc.user_conf.algo; in nand_ecc_get_sw_engine()
593 algo = nand->ecc.defaults.algo; in nand_ecc_get_sw_engine()
608 struct nand_ecc_engine *nand_ecc_get_on_die_hw_engine(struct nand_device *nand) in nand_ecc_get_on_die_hw_engine() argument
610 return nand->ecc.ondie_engine; in nand_ecc_get_on_die_hw_engine()
616 MODULE_DESCRIPTION("Generic ECC engine");