Lines Matching full:ecc
163 * the NAND controller performs reads/writes with ECC in 516 byte chunks.
177 /* ECC modes supported by the controller */
416 * of a page, consisting of all data, ecc, spare
419 * by ECC
420 * @use_ecc: request the controller to use ECC for the
422 * @bch_enabled: flag to tell whether BCH ECC mode is used
423 * @ecc_bytes_hw: ECC bytes used by controller hardware for this
431 * ecc/non-ecc mode for the current nand flash
460 * @ecc_modes - ecc mode for NAND
1392 struct nand_ecc_ctrl *ecc = &chip->ecc; in parse_erase_write_errors() local
1396 num_cw = command == NAND_CMD_PAGEPROG ? ecc->steps : 1; in parse_erase_write_errors()
1442 struct nand_ecc_ctrl *ecc = &chip->ecc; in qcom_nandc_command() local
1477 update_rw_regs(host, ecc->steps, true); in qcom_nandc_command()
1513 * when using BCH ECC, the HW flags an error in NAND_FLASH_STATUS if it read
1516 * when using RS ECC, the HW reports the same erros when reading an erased CW,
1520 * verify if the page is erased or not, and fix up the page for RS ECC by
1590 struct nand_ecc_ctrl *ecc = &chip->ecc; in qcom_nandc_read_cw_raw() local
1602 data_size1 = mtd->writesize - host->cw_size * (ecc->steps - 1); in qcom_nandc_read_cw_raw()
1605 if (cw == (ecc->steps - 1)) { in qcom_nandc_read_cw_raw()
1606 data_size2 = ecc->size - data_size1 - in qcom_nandc_read_cw_raw()
1607 ((ecc->steps - 1) * 4); in qcom_nandc_read_cw_raw()
1608 oob_size2 = (ecc->steps * 4) + host->ecc_bytes_hw + in qcom_nandc_read_cw_raw()
1653 * number of 0 in each CW for which ECC engine returns the uncorrectable
1655 * equal to the ecc->strength for each CW.
1663 * The BBM and spare bytes bit flip won’t affect the ECC so don’t check
1673 struct nand_ecc_ctrl *ecc = &chip->ecc; in check_for_erased_page() local
1685 for_each_set_bit(cw, &uncorrectable_cws, ecc->steps) { in check_for_erased_page()
1686 if (cw == (ecc->steps - 1)) { in check_for_erased_page()
1687 data_size = ecc->size - ((ecc->steps - 1) * 4); in check_for_erased_page()
1688 oob_size = (ecc->steps * 4) + host->ecc_bytes_hw; in check_for_erased_page()
1696 cw_oob_buf = oob_buf + (cw * ecc->bytes); in check_for_erased_page()
1710 0, ecc->strength); in check_for_erased_page()
1724 * errors. this is equivalent to what 'ecc->correct()' would do.
1732 struct nand_ecc_ctrl *ecc = &chip->ecc; in parse_read_errors() local
1742 for (i = 0; i < ecc->steps; i++, buf++) { in parse_read_errors()
1746 if (i == (ecc->steps - 1)) { in parse_read_errors()
1747 data_len = ecc->size - ((ecc->steps - 1) << 2); in parse_read_errors()
1748 oob_len = ecc->steps << 2; in parse_read_errors()
1759 * Check ECC failure for each codeword. ECC failure can in parse_read_errors()
1761 * 1. If number of bitflips are greater than ECC engine in parse_read_errors()
1768 * For BCH ECC, ignore erased codeword errors, if in parse_read_errors()
1775 * For RS ECC, HW reports the erased CW by placing in parse_read_errors()
1798 * No ECC or operational errors happened. Check the number of in parse_read_errors()
1812 oob_buf += oob_len + ecc->bytes; in parse_read_errors()
1827 * helper to perform the actual page read operation, used by ecc->read_page(),
1828 * ecc->read_oob()
1835 struct nand_ecc_ctrl *ecc = &chip->ecc; in read_page_ecc() local
1842 for (i = 0; i < ecc->steps; i++) { in read_page_ecc()
1845 if (i == (ecc->steps - 1)) { in read_page_ecc()
1846 data_size = ecc->size - ((ecc->steps - 1) << 2); in read_page_ecc()
1847 oob_size = (ecc->steps << 2) + host->ecc_bytes_hw + in read_page_ecc()
1874 * when ecc is enabled, the controller doesn't read the real in read_page_ecc()
1876 * consistent layout across RAW and ECC reads, we just in read_page_ecc()
1915 struct nand_ecc_ctrl *ecc = &chip->ecc; in copy_last_cw() local
1926 set_address(host, host->cw_size * (ecc->steps - 1), page); in copy_last_cw()
1942 /* implements ecc->read_page() */
1959 /* implements ecc->read_page_raw() */
1965 struct nand_ecc_ctrl *ecc = &chip->ecc; in qcom_nandc_read_page_raw() local
1969 for (cw = 0; cw < ecc->steps; cw++) { in qcom_nandc_read_page_raw()
1976 oob_buf += ecc->bytes; in qcom_nandc_read_page_raw()
1982 /* implements ecc->read_oob() */
1987 struct nand_ecc_ctrl *ecc = &chip->ecc; in qcom_nandc_read_oob() local
1994 update_rw_regs(host, ecc->steps, true); in qcom_nandc_read_oob()
1999 /* implements ecc->write_page() */
2005 struct nand_ecc_ctrl *ecc = &chip->ecc; in qcom_nandc_write_page() local
2018 update_rw_regs(host, ecc->steps, false); in qcom_nandc_write_page()
2021 for (i = 0; i < ecc->steps; i++) { in qcom_nandc_write_page()
2024 if (i == (ecc->steps - 1)) { in qcom_nandc_write_page()
2025 data_size = ecc->size - ((ecc->steps - 1) << 2); in qcom_nandc_write_page()
2026 oob_size = (ecc->steps << 2) + host->ecc_bytes_hw + in qcom_nandc_write_page()
2030 oob_size = ecc->bytes; in qcom_nandc_write_page()
2035 i == (ecc->steps - 1) ? NAND_BAM_NO_EOT : 0); in qcom_nandc_write_page()
2038 * when ECC is enabled, we don't really need to write anything in qcom_nandc_write_page()
2040 * just contain ECC bytes that's written by the controller in qcom_nandc_write_page()
2044 if (i == (ecc->steps - 1)) { in qcom_nandc_write_page()
2069 /* implements ecc->write_page_raw() */
2077 struct nand_ecc_ctrl *ecc = &chip->ecc; in qcom_nandc_write_page_raw() local
2089 update_rw_regs(host, ecc->steps, false); in qcom_nandc_write_page_raw()
2092 for (i = 0; i < ecc->steps; i++) { in qcom_nandc_write_page_raw()
2096 data_size1 = mtd->writesize - host->cw_size * (ecc->steps - 1); in qcom_nandc_write_page_raw()
2099 if (i == (ecc->steps - 1)) { in qcom_nandc_write_page_raw()
2100 data_size2 = ecc->size - data_size1 - in qcom_nandc_write_page_raw()
2101 ((ecc->steps - 1) << 2); in qcom_nandc_write_page_raw()
2102 oob_size2 = (ecc->steps << 2) + host->ecc_bytes_hw + in qcom_nandc_write_page_raw()
2143 * implements ecc->write_oob()
2146 * since ECC is calculated for the combined codeword. So update the OOB from
2154 struct nand_ecc_ctrl *ecc = &chip->ecc; in qcom_nandc_write_oob() local
2163 data_size = ecc->size - ((ecc->steps - 1) << 2); in qcom_nandc_write_oob()
2171 set_address(host, host->cw_size * (ecc->steps - 1), page); in qcom_nandc_write_oob()
2196 struct nand_ecc_ctrl *ecc = &chip->ecc; in qcom_nandc_block_bad() local
2203 * the beginning of the last codeword, we don't care about reading ecc in qcom_nandc_block_bad()
2219 bbpos = mtd->writesize - host->cw_size * (ecc->steps - 1); in qcom_nandc_block_bad()
2233 struct nand_ecc_ctrl *ecc = &chip->ecc; in qcom_nandc_block_markbad() local
2250 set_address(host, host->cw_size * (ecc->steps - 1), page); in qcom_nandc_block_markbad()
2331 * Layout with ECC enabled:
2335 * | DATA xx..ECC..yy| | DATA **SPARE**xx..ECC..yy|
2343 * . = ECC bytes
2353 * codeword is 528 and 532 bytes for 4 bit and 8 bit ECC modes respectively.
2354 * the number of ECC bytes vary based on the ECC strength and the bus width.
2357 * 12/16 bytes consist of ECC and reserved data. The nth codeword contains
2360 * When we access a page with ECC enabled, the reserved bytes(s) are not
2365 * Layout with ECC disabled:
2369 * | DATA1 yy DATA2 xx..ECC..| | DATA1 bb DATA2 **SPARE**xx..ECC..|
2377 * . = ECC bytes
2384 * when the ECC block is disabled, one reserved byte (or two for 16 bit bus
2388 * In order to have a consistent layout between RAW and ECC modes, we assume
2393 * |yyxx..ECC..| |bb*FREEOOB*xx..ECC..|
2401 * . = ECC bytes
2403 * y = Dummy bad block byte(s) (inaccessible when ECC enabled)
2405 * b = Real bad block byte(s) (inaccessible when ECC enabled)
2407 * This layout is read as is when ECC is disabled. When ECC is enabled, the
2409 * and assumed as 0xffs when we read a page/oob. The ECC, unused and
2410 * dummy/real bad block bytes are grouped as ecc bytes (i.e, ecc->bytes is
2418 struct nand_ecc_ctrl *ecc = &chip->ecc; in qcom_nand_ooblayout_ecc() local
2424 oobregion->length = (ecc->bytes * (ecc->steps - 1)) + in qcom_nand_ooblayout_ecc()
2440 struct nand_ecc_ctrl *ecc = &chip->ecc; in qcom_nand_ooblayout_free() local
2445 oobregion->length = ecc->steps * 4; in qcom_nand_ooblayout_free()
2446 oobregion->offset = ((ecc->steps - 1) * ecc->bytes) + host->bbm_size; in qcom_nand_ooblayout_free()
2452 .ecc = qcom_nand_ooblayout_ecc,
2468 struct nand_ecc_ctrl *ecc = &chip->ecc; in qcom_nand_attach_chip() local
2475 ecc->size = NANDC_STEP_SIZE; in qcom_nand_attach_chip()
2480 * Each CW has 4 available OOB bytes which will be protected with ECC in qcom_nand_attach_chip()
2481 * so remaining bytes can be used for ECC. in qcom_nand_attach_chip()
2486 dev_err(nandc->dev, "No valid ECC settings possible\n"); in qcom_nand_attach_chip()
2490 if (ecc->strength >= 8) { in qcom_nand_attach_chip()
2491 /* 8 bit ECC defaults to BCH ECC on all platforms */ in qcom_nand_attach_chip()
2506 * if the controller supports BCH for 4 bit ECC, the controller in qcom_nand_attach_chip()
2507 * uses lesser bytes for ECC. If RS is used, the ECC bytes is in qcom_nand_attach_chip()
2539 * we consider ecc->bytes as the sum of all the non-data content in a in qcom_nand_attach_chip()
2541 * all the bytes aren't used for ECC).It is always 16 bytes for 8 bit in qcom_nand_attach_chip()
2542 * ECC and 12 bytes for 4 bit ECC in qcom_nand_attach_chip()
2544 ecc->bytes = host->ecc_bytes_hw + host->spare_bytes + host->bbm_size; in qcom_nand_attach_chip()
2546 ecc->read_page = qcom_nandc_read_page; in qcom_nand_attach_chip()
2547 ecc->read_page_raw = qcom_nandc_read_page_raw; in qcom_nand_attach_chip()
2548 ecc->read_oob = qcom_nandc_read_oob; in qcom_nand_attach_chip()
2549 ecc->write_page = qcom_nandc_write_page; in qcom_nand_attach_chip()
2550 ecc->write_page_raw = qcom_nandc_write_page_raw; in qcom_nand_attach_chip()
2551 ecc->write_oob = qcom_nandc_write_oob; in qcom_nand_attach_chip()
2553 ecc->engine_type = NAND_ECC_ENGINE_TYPE_ON_HOST; in qcom_nand_attach_chip()
2562 * spare data with ECC too. We protect spare data by default, so we set in qcom_nand_attach_chip()
2568 * total bytes in a step, either 528 bytes for 4 bit ECC, or 532 bytes in qcom_nand_attach_chip()
2569 * for 8 bit ECC in qcom_nand_attach_chip()
2571 host->cw_size = host->cw_data + ecc->bytes; in qcom_nand_attach_chip()
2623 host->cw_size, host->cw_data, ecc->strength, ecc->bytes, in qcom_nand_attach_chip()
2833 * of a page with ECC disabled. currently, the nand_base and nand_bbt in qcom_nand_host_init_and_register()
2834 * helpers don't allow us to read BB from a nand chip with ECC in qcom_nand_host_init_and_register()