Lines Matching defs:ecc
262 res = chip->ecc.read_oob(chip, first_page + page_offset);
433 status = chip->ecc.write_oob_raw(chip, page & chip->pagemask);
435 status = chip->ecc.write_oob(chip, page & chip->pagemask);
2500 * @ecc: ECC buffer
2535 void *ecc, int ecclen,
2548 ecc_bitflips = nand_check_erased_buf(ecc, ecclen, bitflips_threshold);
2563 memset(ecc, 0xff, ecclen);
2588 * nand_read_page_raw - [INTERN] read raw page data without ecc
2659 * nand_read_page_raw_syndrome - [INTERN] read raw page data without ecc
2671 int eccsize = chip->ecc.size;
2672 int eccbytes = chip->ecc.bytes;
2680 for (steps = chip->ecc.steps; steps > 0; steps--) {
2687 if (chip->ecc.prepad) {
2688 ret = nand_read_data_op(chip, oob, chip->ecc.prepad,
2693 oob += chip->ecc.prepad;
2702 if (chip->ecc.postpad) {
2703 ret = nand_read_data_op(chip, oob, chip->ecc.postpad,
2708 oob += chip->ecc.postpad;
2733 int i, eccsize = chip->ecc.size, ret;
2734 int eccbytes = chip->ecc.bytes;
2735 int eccsteps = chip->ecc.steps;
2737 uint8_t *ecc_calc = chip->ecc.calc_buf;
2738 uint8_t *ecc_code = chip->ecc.code_buf;
2741 chip->ecc.read_page_raw(chip, buf, 1, page);
2744 chip->ecc.calculate(chip, p, &ecc_calc[i]);
2747 chip->ecc.total);
2751 eccsteps = chip->ecc.steps;
2757 stat = chip->ecc.correct(chip, p, &ecc_code[i], &ecc_calc[i]);
2790 start_step = data_offs / chip->ecc.size;
2791 end_step = (data_offs + readlen - 1) / chip->ecc.size;
2793 index = start_step * chip->ecc.bytes;
2795 /* Data size aligned to ECC ecc.size */
2796 datafrag_len = num_steps * chip->ecc.size;
2797 eccfrag_len = num_steps * chip->ecc.bytes;
2799 data_col_addr = start_step * chip->ecc.size;
2807 for (i = 0; i < eccfrag_len ; i += chip->ecc.bytes, p += chip->ecc.size)
2808 chip->ecc.calculate(chip, p, &chip->ecc.calc_buf[i]);
2812 * ecc.pos. Let's make sure that there are no gaps in ECC positions.
2836 if ((oobregion.offset + (num_steps * chip->ecc.bytes)) &
2848 ret = mtd_ooblayout_get_eccbytes(mtd, chip->ecc.code_buf,
2854 for (i = 0; i < eccfrag_len ; i += chip->ecc.bytes, p += chip->ecc.size) {
2857 stat = chip->ecc.correct(chip, p, &chip->ecc.code_buf[i],
2858 &chip->ecc.calc_buf[i]);
2860 (chip->ecc.options & NAND_ECC_GENERIC_ERASED_CHECK)) {
2862 stat = nand_check_erased_ecc_chunk(p, chip->ecc.size,
2863 &chip->ecc.code_buf[i],
2864 chip->ecc.bytes,
2866 chip->ecc.strength);
2892 int i, eccsize = chip->ecc.size, ret;
2893 int eccbytes = chip->ecc.bytes;
2894 int eccsteps = chip->ecc.steps;
2896 uint8_t *ecc_calc = chip->ecc.calc_buf;
2897 uint8_t *ecc_code = chip->ecc.code_buf;
2905 chip->ecc.hwctl(chip, NAND_ECC_READ);
2911 chip->ecc.calculate(chip, p, &ecc_calc[i]);
2920 chip->ecc.total);
2924 eccsteps = chip->ecc.steps;
2930 stat = chip->ecc.correct(chip, p, &ecc_code[i], &ecc_calc[i]);
2932 (chip->ecc.options & NAND_ECC_GENERIC_ERASED_CHECK)) {
2937 chip->ecc.strength);
2964 int ret, i, eccsize = chip->ecc.size;
2965 int eccbytes = chip->ecc.bytes;
2966 int eccsteps = chip->ecc.steps;
2967 int eccpadbytes = eccbytes + chip->ecc.prepad + chip->ecc.postpad;
2979 chip->ecc.hwctl(chip, NAND_ECC_READ);
2985 if (chip->ecc.prepad) {
2986 ret = nand_read_data_op(chip, oob, chip->ecc.prepad,
2991 oob += chip->ecc.prepad;
2994 chip->ecc.hwctl(chip, NAND_ECC_READSYN);
3000 stat = chip->ecc.correct(chip, p, oob, NULL);
3004 if (chip->ecc.postpad) {
3005 ret = nand_read_data_op(chip, oob, chip->ecc.postpad,
3010 oob += chip->ecc.postpad;
3014 (chip->ecc.options & NAND_ECC_GENERIC_ERASED_CHECK)) {
3016 stat = nand_check_erased_ecc_chunk(p, chip->ecc.size,
3020 chip->ecc.strength);
3169 * the read methods return max bitflips per ecc step.
3172 ret = chip->ecc.read_page_raw(chip, bufpoi,
3177 ret = chip->ecc.read_subpage(chip, col, bytes,
3180 ret = chip->ecc.read_page(chip, bufpoi,
3308 int chunk = chip->ecc.bytes + chip->ecc.prepad + chip->ecc.postpad;
3309 int eccsize = chip->ecc.size;
3313 ret = nand_read_page_op(chip, page, chip->ecc.size, NULL, 0);
3317 for (i = 0; i < chip->ecc.steps; i++) {
3375 int chunk = chip->ecc.bytes + chip->ecc.prepad + chip->ecc.postpad;
3376 int eccsize = chip->ecc.size, length = mtd->oobsize;
3377 int ret, i, len, pos, sndcmd = 0, steps = chip->ecc.steps;
3381 * data-ecc-data-ecc ... ecc-oob
3383 * data-pad-ecc-pad-data-pad .... ecc-pad-oob
3385 if (!chip->ecc.prepad && !chip->ecc.postpad) {
3475 ret = chip->ecc.read_oob_raw(chip, page);
3477 ret = chip->ecc.read_oob(chip, page);
3644 int eccsize = chip->ecc.size;
3645 int eccbytes = chip->ecc.bytes;
3653 for (steps = chip->ecc.steps; steps > 0; steps--) {
3660 if (chip->ecc.prepad) {
3661 ret = nand_write_data_op(chip, oob, chip->ecc.prepad,
3666 oob += chip->ecc.prepad;
3675 if (chip->ecc.postpad) {
3676 ret = nand_write_data_op(chip, oob, chip->ecc.postpad,
3681 oob += chip->ecc.postpad;
3705 int i, eccsize = chip->ecc.size, ret;
3706 int eccbytes = chip->ecc.bytes;
3707 int eccsteps = chip->ecc.steps;
3708 uint8_t *ecc_calc = chip->ecc.calc_buf;
3713 chip->ecc.calculate(chip, p, &ecc_calc[i]);
3716 chip->ecc.total);
3720 return chip->ecc.write_page_raw(chip, buf, 1, page);
3734 int i, eccsize = chip->ecc.size, ret;
3735 int eccbytes = chip->ecc.bytes;
3736 int eccsteps = chip->ecc.steps;
3737 uint8_t *ecc_calc = chip->ecc.calc_buf;
3745 chip->ecc.hwctl(chip, NAND_ECC_WRITE);
3751 chip->ecc.calculate(chip, p, &ecc_calc[i]);
3755 chip->ecc.total);
3782 uint8_t *ecc_calc = chip->ecc.calc_buf;
3783 int ecc_size = chip->ecc.size;
3784 int ecc_bytes = chip->ecc.bytes;
3785 int ecc_steps = chip->ecc.steps;
3797 chip->ecc.hwctl(chip, NAND_ECC_WRITE);
3808 chip->ecc.calculate(chip, buf, ecc_calc);
3822 ecc_calc = chip->ecc.calc_buf;
3824 chip->ecc.total);
3851 int i, eccsize = chip->ecc.size;
3852 int eccbytes = chip->ecc.bytes;
3853 int eccsteps = chip->ecc.steps;
3863 chip->ecc.hwctl(chip, NAND_ECC_WRITE);
3869 if (chip->ecc.prepad) {
3870 ret = nand_write_data_op(chip, oob, chip->ecc.prepad,
3875 oob += chip->ecc.prepad;
3878 chip->ecc.calculate(chip, p, oob);
3886 if (chip->ecc.postpad) {
3887 ret = nand_write_data_op(chip, oob, chip->ecc.postpad,
3892 oob += chip->ecc.postpad;
3925 chip->ecc.write_subpage)
3931 status = chip->ecc.write_page_raw(chip, buf, oob_required,
3934 status = chip->ecc.write_subpage(chip, offset, data_len, buf,
3937 status = chip->ecc.write_page(chip, buf, oob_required, page);
4899 err = of_property_read_string(np, "nand-ecc-mode", &pm);
4932 err = of_property_read_string(np, "nand-ecc-mode", &pm);
4946 err = of_property_read_string(np, "nand-ecc-mode", &pm);
4960 struct nand_ecc_props *user_conf = &chip->base.ecc.user_conf;
5017 nand->ecc.defaults.engine_type = NAND_ECC_ENGINE_TYPE_ON_HOST;
5024 if (nand->ecc.user_conf.engine_type != NAND_ECC_ENGINE_TYPE_INVALID)
5025 chip->ecc.engine_type = nand->ecc.user_conf.engine_type;
5026 if (chip->ecc.engine_type == NAND_ECC_ENGINE_TYPE_INVALID)
5027 chip->ecc.engine_type = nand->ecc.defaults.engine_type;
5029 chip->ecc.placement = nand->ecc.user_conf.placement;
5030 chip->ecc.algo = nand->ecc.user_conf.algo;
5031 chip->ecc.strength = nand->ecc.user_conf.strength;
5032 chip->ecc.size = nand->ecc.user_conf.step_size;
5140 struct nand_ecc_ctrl *ecc = &chip->ecc;
5142 switch (ecc->placement) {
5146 if (!ecc->read_page)
5147 ecc->read_page = nand_read_page_hwecc;
5148 if (!ecc->write_page)
5149 ecc->write_page = nand_write_page_hwecc;
5150 if (!ecc->read_page_raw)
5151 ecc->read_page_raw = nand_read_page_raw;
5152 if (!ecc->write_page_raw)
5153 ecc->write_page_raw = nand_write_page_raw;
5154 if (!ecc->read_oob)
5155 ecc->read_oob = nand_read_oob_std;
5156 if (!ecc->write_oob)
5157 ecc->write_oob = nand_write_oob_std;
5158 if (!ecc->read_subpage)
5159 ecc->read_subpage = nand_read_subpage;
5160 if (!ecc->write_subpage && ecc->hwctl && ecc->calculate)
5161 ecc->write_subpage = nand_write_subpage_hwecc;
5165 if ((!ecc->calculate || !ecc->correct || !ecc->hwctl) &&
5166 (!ecc->read_page ||
5167 ecc->read_page == nand_read_page_hwecc ||
5168 !ecc->write_page ||
5169 ecc->write_page == nand_write_page_hwecc)) {
5174 if (!ecc->read_page)
5175 ecc->read_page = nand_read_page_syndrome;
5176 if (!ecc->write_page)
5177 ecc->write_page = nand_write_page_syndrome;
5178 if (!ecc->read_page_raw)
5179 ecc->read_page_raw = nand_read_page_raw_syndrome;
5180 if (!ecc->write_page_raw)
5181 ecc->write_page_raw = nand_write_page_raw_syndrome;
5182 if (!ecc->read_oob)
5183 ecc->read_oob = nand_read_oob_syndrome;
5184 if (!ecc->write_oob)
5185 ecc->write_oob = nand_write_oob_syndrome;
5190 ecc->placement);
5201 struct nand_ecc_ctrl *ecc = &chip->ecc;
5203 if (WARN_ON(ecc->engine_type != NAND_ECC_ENGINE_TYPE_SOFT))
5206 switch (ecc->algo) {
5208 ecc->calculate = nand_calculate_ecc;
5209 ecc->correct = nand_correct_data;
5210 ecc->read_page = nand_read_page_swecc;
5211 ecc->read_subpage = nand_read_subpage;
5212 ecc->write_page = nand_write_page_swecc;
5213 if (!ecc->read_page_raw)
5214 ecc->read_page_raw = nand_read_page_raw;
5215 if (!ecc->write_page_raw)
5216 ecc->write_page_raw = nand_write_page_raw;
5217 ecc->read_oob = nand_read_oob_std;
5218 ecc->write_oob = nand_write_oob_std;
5219 if (!ecc->size)
5220 ecc->size = 256;
5221 ecc->bytes = 3;
5222 ecc->strength = 1;
5225 ecc->options |= NAND_ECC_SOFT_HAMMING_SM_ORDER;
5233 ecc->calculate = nand_bch_calculate_ecc;
5234 ecc->correct = nand_bch_correct_data;
5235 ecc->read_page = nand_read_page_swecc;
5236 ecc->read_subpage = nand_read_subpage;
5237 ecc->write_page = nand_write_page_swecc;
5238 if (!ecc->read_page_raw)
5239 ecc->read_page_raw = nand_read_page_raw;
5240 if (!ecc->write_page_raw)
5241 ecc->write_page_raw = nand_write_page_raw;
5242 ecc->read_oob = nand_read_oob_std;
5243 ecc->write_oob = nand_write_oob_std;
5246 * Board driver should supply ecc.size and ecc.strength
5250 if (!ecc->size && (mtd->oobsize >= 64)) {
5251 ecc->size = 512;
5252 ecc->strength = 4;
5256 * if no ecc placement scheme was provided pickup the default
5276 nanddev->ecc.user_conf.flags & NAND_ECC_MAXIMIZE_STRENGTH) {
5280 ecc->size = 1024;
5281 steps = mtd->writesize / ecc->size;
5285 ecc->strength = bytes * 8 / fls(8 * ecc->size);
5289 ecc->bytes = 0;
5290 ecc->priv = nand_bch_init(mtd);
5291 if (!ecc->priv) {
5318 int preset_step = chip->ecc.size;
5319 int preset_strength = chip->ecc.strength;
5344 chip->ecc.bytes = ecc_bytes;
5433 chip->ecc.size = best_step;
5434 chip->ecc.strength = best_strength;
5435 chip->ecc.bytes = best_ecc_bytes;
5465 /* If chip->ecc.size is already set, respect it */
5466 if (chip->ecc.size && step_size != chip->ecc.size)
5503 chip->ecc.size = best_step;
5504 chip->ecc.strength = best_strength;
5505 chip->ecc.bytes = best_ecc_bytes;
5520 * 2. If the user provided the nand-ecc-maximize property, then select maximum
5537 if (chip->ecc.size && chip->ecc.strength)
5540 if (nanddev->ecc.user_conf.flags & NAND_ECC_MAXIMIZE_STRENGTH)
5605 struct nand_ecc_ctrl *ecc = &chip->ecc;
5637 !(ecc->engine_type == NAND_ECC_ENGINE_TYPE_SOFT &&
5638 ecc->algo == NAND_ECC_ALGO_BCH)) {
5657 if (ecc->engine_type == NAND_ECC_ENGINE_TYPE_NONE) {
5675 switch (ecc->engine_type) {
5681 if (mtd->writesize >= ecc->size) {
5682 if (!ecc->strength) {
5683 WARN(1, "Driver must set ecc.strength when using hardware ECC\n");
5690 ecc->size, mtd->writesize);
5691 ecc->engine_type = NAND_ECC_ENGINE_TYPE_SOFT;
5692 ecc->algo = NAND_ECC_ALGO_HAMMING;
5702 if (!ecc->read_page || !ecc->write_page) {
5707 if (!ecc->read_oob)
5708 ecc->read_oob = nand_read_oob_std;
5709 if (!ecc->write_oob)
5710 ecc->write_oob = nand_write_oob_std;
5715 ecc->read_page = nand_read_page_raw;
5716 ecc->write_page = nand_write_page_raw;
5717 ecc->read_oob = nand_read_oob_std;
5718 ecc->read_page_raw = nand_read_page_raw;
5719 ecc->write_page_raw = nand_write_page_raw;
5720 ecc->write_oob = nand_write_oob_std;
5721 ecc->size = mtd->writesize;
5722 ecc->bytes = 0;
5723 ecc->strength = 0;
5727 WARN(1, "Invalid NAND_ECC_MODE %d\n", ecc->engine_type);
5732 if (ecc->correct || ecc->calculate) {
5733 ecc->calc_buf = kmalloc(mtd->oobsize, GFP_KERNEL);
5734 ecc->code_buf = kmalloc(mtd->oobsize, GFP_KERNEL);
5735 if (!ecc->calc_buf || !ecc->code_buf) {
5742 if (!ecc->read_oob_raw)
5743 ecc->read_oob_raw = ecc->read_oob;
5744 if (!ecc->write_oob_raw)
5745 ecc->write_oob_raw = ecc->write_oob;
5747 /* propagate ecc info to mtd_info */
5748 mtd->ecc_strength = ecc->strength;
5749 mtd->ecc_step_size = ecc->size;
5755 ecc->steps = mtd->writesize / ecc->size;
5756 if (ecc->steps * ecc->size != mtd->writesize) {
5762 ecc->total = ecc->steps * ecc->bytes;
5763 chip->base.ecc.ctx.total = ecc->total;
5765 if (ecc->total > mtd->oobsize) {
5784 mtd->name, chip->ecc.strength, chip->ecc.size,
5788 /* Allow subpage writes up to ecc.steps. Not possible for MLC flash */
5790 switch (ecc->steps) {
5807 switch (ecc->engine_type) {
5885 kfree(ecc->code_buf);
5886 kfree(ecc->calc_buf);
5952 if (chip->ecc.engine_type == NAND_ECC_ENGINE_TYPE_SOFT &&
5953 chip->ecc.algo == NAND_ECC_ALGO_BCH)
5954 nand_bch_free((struct nand_bch_control *)chip->ecc.priv);
5961 kfree(chip->ecc.code_buf);
5962 kfree(chip->ecc.calc_buf);