Lines Matching defs:ecc
38 #include <linux/mtd/nand-ecc-sw-hamming.h>
39 #include <linux/mtd/nand-ecc-sw-bch.h>
263 res = chip->ecc.read_oob(chip, first_page + page_offset);
476 status = chip->ecc.write_oob_raw(chip, page & chip->pagemask);
478 status = chip->ecc.write_oob(chip, page & chip->pagemask);
2819 * @ecc: ECC buffer
2854 void *ecc, int ecclen,
2867 ecc_bitflips = nand_check_erased_buf(ecc, ecclen, bitflips_threshold);
2882 memset(ecc, 0xff, ecclen);
2907 * nand_read_page_raw - [INTERN] read raw page data without ecc
2978 * nand_read_page_raw_syndrome - [INTERN] read raw page data without ecc
2990 int eccsize = chip->ecc.size;
2991 int eccbytes = chip->ecc.bytes;
2999 for (steps = chip->ecc.steps; steps > 0; steps--) {
3006 if (chip->ecc.prepad) {
3007 ret = nand_read_data_op(chip, oob, chip->ecc.prepad,
3012 oob += chip->ecc.prepad;
3021 if (chip->ecc.postpad) {
3022 ret = nand_read_data_op(chip, oob, chip->ecc.postpad,
3027 oob += chip->ecc.postpad;
3052 int i, eccsize = chip->ecc.size, ret;
3053 int eccbytes = chip->ecc.bytes;
3054 int eccsteps = chip->ecc.steps;
3056 uint8_t *ecc_calc = chip->ecc.calc_buf;
3057 uint8_t *ecc_code = chip->ecc.code_buf;
3060 chip->ecc.read_page_raw(chip, buf, 1, page);
3063 chip->ecc.calculate(chip, p, &ecc_calc[i]);
3066 chip->ecc.total);
3070 eccsteps = chip->ecc.steps;
3076 stat = chip->ecc.correct(chip, p, &ecc_code[i], &ecc_calc[i]);
3109 start_step = data_offs / chip->ecc.size;
3110 end_step = (data_offs + readlen - 1) / chip->ecc.size;
3112 index = start_step * chip->ecc.bytes;
3114 /* Data size aligned to ECC ecc.size */
3115 datafrag_len = num_steps * chip->ecc.size;
3116 eccfrag_len = num_steps * chip->ecc.bytes;
3118 data_col_addr = start_step * chip->ecc.size;
3126 for (i = 0; i < eccfrag_len ; i += chip->ecc.bytes, p += chip->ecc.size)
3127 chip->ecc.calculate(chip, p, &chip->ecc.calc_buf[i]);
3131 * ecc.pos. Let's make sure that there are no gaps in ECC positions.
3155 if ((oobregion.offset + (num_steps * chip->ecc.bytes)) &
3167 ret = mtd_ooblayout_get_eccbytes(mtd, chip->ecc.code_buf,
3173 for (i = 0; i < eccfrag_len ; i += chip->ecc.bytes, p += chip->ecc.size) {
3176 stat = chip->ecc.correct(chip, p, &chip->ecc.code_buf[i],
3177 &chip->ecc.calc_buf[i]);
3179 (chip->ecc.options & NAND_ECC_GENERIC_ERASED_CHECK)) {
3181 stat = nand_check_erased_ecc_chunk(p, chip->ecc.size,
3182 &chip->ecc.code_buf[i],
3183 chip->ecc.bytes,
3185 chip->ecc.strength);
3211 int i, eccsize = chip->ecc.size, ret;
3212 int eccbytes = chip->ecc.bytes;
3213 int eccsteps = chip->ecc.steps;
3215 uint8_t *ecc_calc = chip->ecc.calc_buf;
3216 uint8_t *ecc_code = chip->ecc.code_buf;
3224 chip->ecc.hwctl(chip, NAND_ECC_READ);
3230 chip->ecc.calculate(chip, p, &ecc_calc[i]);
3239 chip->ecc.total);
3243 eccsteps = chip->ecc.steps;
3249 stat = chip->ecc.correct(chip, p, &ecc_code[i], &ecc_calc[i]);
3251 (chip->ecc.options & NAND_ECC_GENERIC_ERASED_CHECK)) {
3256 chip->ecc.strength);
3284 int i, eccsize = chip->ecc.size, ret;
3285 int eccbytes = chip->ecc.bytes;
3286 int eccsteps = chip->ecc.steps;
3288 uint8_t *ecc_code = chip->ecc.code_buf;
3302 chip->ecc.total);
3309 chip->ecc.hwctl(chip, NAND_ECC_READ);
3315 stat = chip->ecc.correct(chip, p, &ecc_code[i], NULL);
3317 (chip->ecc.options & NAND_ECC_GENERIC_ERASED_CHECK)) {
3322 chip->ecc.strength);
3350 int ret, i, eccsize = chip->ecc.size;
3351 int eccbytes = chip->ecc.bytes;
3352 int eccsteps = chip->ecc.steps;
3353 int eccpadbytes = eccbytes + chip->ecc.prepad + chip->ecc.postpad;
3365 chip->ecc.hwctl(chip, NAND_ECC_READ);
3371 if (chip->ecc.prepad) {
3372 ret = nand_read_data_op(chip, oob, chip->ecc.prepad,
3377 oob += chip->ecc.prepad;
3380 chip->ecc.hwctl(chip, NAND_ECC_READSYN);
3386 stat = chip->ecc.correct(chip, p, oob, NULL);
3390 if (chip->ecc.postpad) {
3391 ret = nand_read_data_op(chip, oob, chip->ecc.postpad,
3396 oob += chip->ecc.postpad;
3400 (chip->ecc.options & NAND_ECC_GENERIC_ERASED_CHECK)) {
3402 stat = nand_check_erased_ecc_chunk(p, chip->ecc.size,
3406 chip->ecc.strength);
3603 * the read methods return max bitflips per ecc step.
3606 ret = chip->ecc.read_page_raw(chip, bufpoi,
3611 ret = chip->ecc.read_subpage(chip, col, bytes,
3614 ret = chip->ecc.read_page(chip, bufpoi,
3744 int chunk = chip->ecc.bytes + chip->ecc.prepad + chip->ecc.postpad;
3745 int eccsize = chip->ecc.size;
3749 ret = nand_read_page_op(chip, page, chip->ecc.size, NULL, 0);
3753 for (i = 0; i < chip->ecc.steps; i++) {
3811 int chunk = chip->ecc.bytes + chip->ecc.prepad + chip->ecc.postpad;
3812 int eccsize = chip->ecc.size, length = mtd->oobsize;
3813 int ret, i, len, pos, sndcmd = 0, steps = chip->ecc.steps;
3817 * data-ecc-data-ecc ... ecc-oob
3819 * data-pad-ecc-pad-data-pad .... ecc-pad-oob
3821 if (!chip->ecc.prepad && !chip->ecc.postpad) {
3915 ret = chip->ecc.read_oob_raw(chip, page);
3917 ret = chip->ecc.read_oob(chip, page);
4094 int eccsize = chip->ecc.size;
4095 int eccbytes = chip->ecc.bytes;
4103 for (steps = chip->ecc.steps; steps > 0; steps--) {
4110 if (chip->ecc.prepad) {
4111 ret = nand_write_data_op(chip, oob, chip->ecc.prepad,
4116 oob += chip->ecc.prepad;
4125 if (chip->ecc.postpad) {
4126 ret = nand_write_data_op(chip, oob, chip->ecc.postpad,
4131 oob += chip->ecc.postpad;
4155 int i, eccsize = chip->ecc.size, ret;
4156 int eccbytes = chip->ecc.bytes;
4157 int eccsteps = chip->ecc.steps;
4158 uint8_t *ecc_calc = chip->ecc.calc_buf;
4163 chip->ecc.calculate(chip, p, &ecc_calc[i]);
4166 chip->ecc.total);
4170 return chip->ecc.write_page_raw(chip, buf, 1, page);
4184 int i, eccsize = chip->ecc.size, ret;
4185 int eccbytes = chip->ecc.bytes;
4186 int eccsteps = chip->ecc.steps;
4187 uint8_t *ecc_calc = chip->ecc.calc_buf;
4195 chip->ecc.hwctl(chip, NAND_ECC_WRITE);
4201 chip->ecc.calculate(chip, p, &ecc_calc[i]);
4205 chip->ecc.total);
4232 uint8_t *ecc_calc = chip->ecc.calc_buf;
4233 int ecc_size = chip->ecc.size;
4234 int ecc_bytes = chip->ecc.bytes;
4235 int ecc_steps = chip->ecc.steps;
4247 chip->ecc.hwctl(chip, NAND_ECC_WRITE);
4258 chip->ecc.calculate(chip, buf, ecc_calc);
4272 ecc_calc = chip->ecc.calc_buf;
4274 chip->ecc.total);
4301 int i, eccsize = chip->ecc.size;
4302 int eccbytes = chip->ecc.bytes;
4303 int eccsteps = chip->ecc.steps;
4313 chip->ecc.hwctl(chip, NAND_ECC_WRITE);
4319 if (chip->ecc.prepad) {
4320 ret = nand_write_data_op(chip, oob, chip->ecc.prepad,
4325 oob += chip->ecc.prepad;
4328 chip->ecc.calculate(chip, p, oob);
4336 if (chip->ecc.postpad) {
4337 ret = nand_write_data_op(chip, oob, chip->ecc.postpad,
4342 oob += chip->ecc.postpad;
4375 chip->ecc.write_subpage)
4381 status = chip->ecc.write_page_raw(chip, buf, oob_required,
4384 status = chip->ecc.write_subpage(chip, offset, data_len, buf,
4387 status = chip->ecc.write_page(chip, buf, oob_required, page);
5187 if (chip->ecc.engine_type == NAND_ECC_ENGINE_TYPE_ON_DIE)
5412 err = of_property_read_string(np, "nand-ecc-mode", &pm);
5445 err = of_property_read_string(np, "nand-ecc-mode", &pm);
5459 err = of_property_read_string(np, "nand-ecc-mode", &pm);
5473 struct nand_ecc_props *user_conf = &chip->base.ecc.user_conf;
5599 nand->ecc.defaults.engine_type = NAND_ECC_ENGINE_TYPE_ON_HOST;
5606 if (nand->ecc.user_conf.engine_type != NAND_ECC_ENGINE_TYPE_INVALID)
5607 chip->ecc.engine_type = nand->ecc.user_conf.engine_type;
5608 if (chip->ecc.engine_type == NAND_ECC_ENGINE_TYPE_INVALID)
5609 chip->ecc.engine_type = nand->ecc.defaults.engine_type;
5611 chip->ecc.placement = nand->ecc.user_conf.placement;
5612 chip->ecc.algo = nand->ecc.user_conf.algo;
5613 chip->ecc.strength = nand->ecc.user_conf.strength;
5614 chip->ecc.size = nand->ecc.user_conf.step_size;
5726 base->ecc.user_conf.engine_type = NAND_ECC_ENGINE_TYPE_SOFT;
5727 base->ecc.user_conf.algo = NAND_ECC_ALGO_HAMMING;
5728 base->ecc.user_conf.strength = chip->ecc.strength;
5729 base->ecc.user_conf.step_size = chip->ecc.size;
5735 engine_conf = base->ecc.ctx.priv;
5737 if (chip->ecc.options & NAND_ECC_SOFT_HAMMING_SM_ORDER)
5740 chip->ecc.size = base->ecc.ctx.conf.step_size;
5741 chip->ecc.strength = base->ecc.ctx.conf.strength;
5742 chip->ecc.total = base->ecc.ctx.total;
5743 chip->ecc.steps = nanddev_get_ecc_nsteps(base);
5744 chip->ecc.bytes = base->ecc.ctx.total / nanddev_get_ecc_nsteps(base);
5785 base->ecc.user_conf.engine_type = NAND_ECC_ENGINE_TYPE_SOFT;
5786 base->ecc.user_conf.algo = NAND_ECC_ALGO_BCH;
5787 base->ecc.user_conf.step_size = chip->ecc.size;
5788 base->ecc.user_conf.strength = chip->ecc.strength;
5794 chip->ecc.size = ecc_conf->step_size;
5795 chip->ecc.strength = ecc_conf->strength;
5796 chip->ecc.total = base->ecc.ctx.total;
5797 chip->ecc.steps = nanddev_get_ecc_nsteps(base);
5798 chip->ecc.bytes = base->ecc.ctx.total / nanddev_get_ecc_nsteps(base);
5832 struct nand_ecc_ctrl *ecc = &chip->ecc;
5834 switch (ecc->placement) {
5838 if (!ecc->read_page)
5839 ecc->read_page = nand_read_page_hwecc;
5840 if (!ecc->write_page)
5841 ecc->write_page = nand_write_page_hwecc;
5842 if (!ecc->read_page_raw)
5843 ecc->read_page_raw = nand_read_page_raw;
5844 if (!ecc->write_page_raw)
5845 ecc->write_page_raw = nand_write_page_raw;
5846 if (!ecc->read_oob)
5847 ecc->read_oob = nand_read_oob_std;
5848 if (!ecc->write_oob)
5849 ecc->write_oob = nand_write_oob_std;
5850 if (!ecc->read_subpage)
5851 ecc->read_subpage = nand_read_subpage;
5852 if (!ecc->write_subpage && ecc->hwctl && ecc->calculate)
5853 ecc->write_subpage = nand_write_subpage_hwecc;
5857 if ((!ecc->calculate || !ecc->correct || !ecc->hwctl) &&
5858 (!ecc->read_page ||
5859 ecc->read_page == nand_read_page_hwecc ||
5860 !ecc->write_page ||
5861 ecc->write_page == nand_write_page_hwecc)) {
5866 if (!ecc->read_page)
5867 ecc->read_page = nand_read_page_syndrome;
5868 if (!ecc->write_page)
5869 ecc->write_page = nand_write_page_syndrome;
5870 if (!ecc->read_page_raw)
5871 ecc->read_page_raw = nand_read_page_raw_syndrome;
5872 if (!ecc->write_page_raw)
5873 ecc->write_page_raw = nand_write_page_raw_syndrome;
5874 if (!ecc->read_oob)
5875 ecc->read_oob = nand_read_oob_syndrome;
5876 if (!ecc->write_oob)
5877 ecc->write_oob = nand_write_oob_syndrome;
5882 ecc->placement);
5893 struct nand_ecc_ctrl *ecc = &chip->ecc;
5896 if (WARN_ON(ecc->engine_type != NAND_ECC_ENGINE_TYPE_SOFT))
5899 switch (ecc->algo) {
5901 ecc->calculate = rawnand_sw_hamming_calculate;
5902 ecc->correct = rawnand_sw_hamming_correct;
5903 ecc->read_page = nand_read_page_swecc;
5904 ecc->read_subpage = nand_read_subpage;
5905 ecc->write_page = nand_write_page_swecc;
5906 if (!ecc->read_page_raw)
5907 ecc->read_page_raw = nand_read_page_raw;
5908 if (!ecc->write_page_raw)
5909 ecc->write_page_raw = nand_write_page_raw;
5910 ecc->read_oob = nand_read_oob_std;
5911 ecc->write_oob = nand_write_oob_std;
5912 if (!ecc->size)
5913 ecc->size = 256;
5914 ecc->bytes = 3;
5915 ecc->strength = 1;
5918 ecc->options |= NAND_ECC_SOFT_HAMMING_SM_ORDER;
5932 ecc->calculate = rawnand_sw_bch_calculate;
5933 ecc->correct = rawnand_sw_bch_correct;
5934 ecc->read_page = nand_read_page_swecc;
5935 ecc->read_subpage = nand_read_subpage;
5936 ecc->write_page = nand_write_page_swecc;
5937 if (!ecc->read_page_raw)
5938 ecc->read_page_raw = nand_read_page_raw;
5939 if (!ecc->write_page_raw)
5940 ecc->write_page_raw = nand_write_page_raw;
5941 ecc->read_oob = nand_read_oob_std;
5942 ecc->write_oob = nand_write_oob_std;
5949 if (nanddev->ecc.user_conf.flags & NAND_ECC_MAXIMIZE_STRENGTH &&
5951 nanddev->ecc.user_conf.flags &= ~NAND_ECC_MAXIMIZE_STRENGTH;
5982 int preset_step = chip->ecc.size;
5983 int preset_strength = chip->ecc.strength;
6008 chip->ecc.bytes = ecc_bytes;
6097 chip->ecc.size = best_step;
6098 chip->ecc.strength = best_strength;
6099 chip->ecc.bytes = best_ecc_bytes;
6129 /* If chip->ecc.size is already set, respect it */
6130 if (chip->ecc.size && step_size != chip->ecc.size)
6167 chip->ecc.size = best_step;
6168 chip->ecc.strength = best_strength;
6169 chip->ecc.bytes = best_ecc_bytes;
6184 * 2. If the user provided the nand-ecc-maximize property, then select maximum
6201 if (chip->ecc.size && chip->ecc.strength)
6204 if (nanddev->ecc.user_conf.flags & NAND_ECC_MAXIMIZE_STRENGTH)
6269 struct nand_ecc_ctrl *ecc = &chip->ecc;
6301 !(ecc->engine_type == NAND_ECC_ENGINE_TYPE_SOFT &&
6302 ecc->algo == NAND_ECC_ALGO_BCH) &&
6303 !(ecc->engine_type == NAND_ECC_ENGINE_TYPE_SOFT &&
6304 ecc->algo == NAND_ECC_ALGO_HAMMING)) {
6323 if (ecc->engine_type == NAND_ECC_ENGINE_TYPE_NONE) {
6341 switch (ecc->engine_type) {
6347 if (mtd->writesize >= ecc->size) {
6348 if (!ecc->strength) {
6349 WARN(1, "Driver must set ecc.strength when using hardware ECC\n");
6356 ecc->size, mtd->writesize);
6357 ecc->engine_type = NAND_ECC_ENGINE_TYPE_SOFT;
6358 ecc->algo = NAND_ECC_ALGO_HAMMING;
6368 if (!ecc->read_page || !ecc->write_page) {
6373 if (!ecc->read_oob)
6374 ecc->read_oob = nand_read_oob_std;
6375 if (!ecc->write_oob)
6376 ecc->write_oob = nand_write_oob_std;
6381 ecc->read_page = nand_read_page_raw;
6382 ecc->write_page = nand_write_page_raw;
6383 ecc->read_oob = nand_read_oob_std;
6384 ecc->read_page_raw = nand_read_page_raw;
6385 ecc->write_page_raw = nand_write_page_raw;
6386 ecc->write_oob = nand_write_oob_std;
6387 ecc->size = mtd->writesize;
6388 ecc->bytes = 0;
6389 ecc->strength = 0;
6393 WARN(1, "Invalid NAND_ECC_MODE %d\n", ecc->engine_type);
6398 if (ecc->correct || ecc->calculate) {
6399 ecc->calc_buf = kmalloc(mtd->oobsize, GFP_KERNEL);
6400 ecc->code_buf = kmalloc(mtd->oobsize, GFP_KERNEL);
6401 if (!ecc->calc_buf || !ecc->code_buf) {
6408 if (!ecc->read_oob_raw)
6409 ecc->read_oob_raw = ecc->read_oob;
6410 if (!ecc->write_oob_raw)
6411 ecc->write_oob_raw = ecc->write_oob;
6413 /* propagate ecc info to mtd_info */
6414 mtd->ecc_strength = ecc->strength;
6415 mtd->ecc_step_size = ecc->size;
6421 if (!ecc->steps)
6422 ecc->steps = mtd->writesize / ecc->size;
6423 if (ecc->steps * ecc->size != mtd->writesize) {
6429 if (!ecc->total) {
6430 ecc->total = ecc->steps * ecc->bytes;
6431 chip->base.ecc.ctx.total = ecc->total;
6434 if (ecc->total > mtd->oobsize) {
6453 mtd->name, chip->ecc.strength, chip->ecc.size,
6457 /* Allow subpage writes up to ecc.steps. Not possible for MLC flash */
6459 switch (ecc->steps) {
6476 switch (ecc->engine_type) {
6569 kfree(ecc->code_buf);
6570 kfree(ecc->calc_buf);
6636 if (chip->ecc.engine_type == NAND_ECC_ENGINE_TYPE_SOFT) {
6637 if (chip->ecc.algo == NAND_ECC_ALGO_HAMMING)
6639 else if (chip->ecc.algo == NAND_ECC_ALGO_BCH)
6651 kfree(chip->ecc.code_buf);
6652 kfree(chip->ecc.calc_buf);