Lines Matching defs:page
349 * Now, the NAND chip with 2K page(data chunk is 512byte) shows below:
367 * P : the page size for BCH module.
370 * N : The chunk count of per page.
371 * M : the metasize of per page.
373 * P': the nand chip's page size.
384 * of page, and the delta is:
393 * view of the page is :
422 * N : The chunk count of per page.
424 * M : the metasize of per page.
496 /* nand required but changing ecc page layout */
638 * the physical block mark within the ECC-based view of the page.
640 * NAND chip with 2K page shows below:
651 * of page, and the delta is:
673 * within the ECC-based view of the page is still in the data chunk,
677 * physical block mark within the ECC-based view of the page:
1087 * else we will use all the (page + OOB).
1335 * buffer of the real NAND page size when the gpmi_alloc_dma_buffer
1388 * the ECC engine applies its own view to the bits in the page, the
1458 * code in case we have bitflips in an erased page. As
1461 * at this point that we are reading an erased page and
1463 * ecc_strength bitflips. If this is a page with random
1526 int oob_required, int page)
1537 ret = nand_read_page_op(chip, page, 0, buf, geo->page_size);
1566 /* Fake a virtual small page for the subpage read */
1568 uint32_t len, uint8_t *buf, int page)
1592 * we have to read out the whole page.
1599 "page:%d, first:%d, last:%d, marker at:%d\n",
1600 page, first, last, marker_pos);
1601 return gpmi_ecc_read_page(chip, buf, 0, page);
1651 ret = nand_read_page_op(chip, page, col, buf, page_size);
1655 dev_dbg(this->dev, "page:%d(%d:%d)%d, chunk:(%d:%d), BCH PG size:%d\n",
1656 page, offs, len, col, first, n, page_size);
1664 int oob_required, int page)
1670 dev_dbg(this->dev, "ecc write page.\n");
1688 return nand_prog_page_op(chip, page, 0, buf, nfc_geo->page_size);
1703 * the physical page.
1710 * page, using the conventional definition of which bytes are data and which
1712 * in the page, without the distortions applied by our ECC engine.
1727 * Swapping | page and return it. It | |
1733 * | page and also the block | |
1741 * giving an accurate view of the actual, physical bytes in the page (we're
1746 * easy. When reading a page, for example, the NAND Flash MTD code calls our
1748 * ECC-based or raw view of the page is implicit in which function it calls
1751 static int gpmi_ecc_read_oob(struct nand_chip *chip, int page)
1761 ret = nand_read_page_op(chip, page, mtd->writesize, chip->oob_poi,
1773 ret = nand_read_page_op(chip, page, 0, chip->oob_poi, 1);
1781 static int gpmi_ecc_write_oob(struct nand_chip *chip, int page)
1794 return nand_prog_page_op(chip, page, mtd->writesize + of.offset,
1799 * This function reads a NAND page without involving the ECC engine (no HW
1805 * page into the provided buffers, which is why we're using nand_extract_bits().
1811 int oob_required, int page)
1826 ret = nand_read_page_op(chip, page, 0, tmp_buf,
1884 * This function writes a NAND page without involving the ECC engine (no HW
1890 * final page, which is why we're using nand_extract_bits().
1896 int oob_required, int page)
1920 * beginning of the page, as imposed by the GPMI layout.
1962 return nand_prog_page_op(chip, page, 0, tmp_buf,
1966 static int gpmi_ecc_read_oob_raw(struct nand_chip *chip, int page)
1968 return gpmi_ecc_read_page_raw(chip, NULL, 1, page);
1971 static int gpmi_ecc_write_oob_raw(struct nand_chip *chip, int page)
1973 return gpmi_ecc_write_page_raw(chip, NULL, 1, page);
1982 int column, page, chipnr;
1993 /* Shift to get page */
1994 page = (int)(ofs >> chip->page_shift);
1996 ret = nand_prog_page_op(chip, page, column, block_mark, 1);
2037 unsigned int page;
2053 /* Compute the page addresses. */
2054 page = stride * rom_geo->stride_size_in_pages;
2056 dev_dbg(dev, "Looking for a fingerprint in page 0x%x\n", page);
2060 * and starts in the 12th byte of the page.
2062 ret = nand_read_page_op(chip, page, 12, buffer,
2097 unsigned int page;
2128 /* Write the NCB fingerprint into the page buffer. */
2135 /* Compute the page addresses. */
2136 page = stride * rom_geo->stride_size_in_pages;
2138 /* Write the first page of the current stride. */
2139 dev_dbg(dev, "Writing an NCB fingerprint in page 0x%x\n", page);
2141 status = chip->ecc.write_page_raw(chip, buffer, 0, page);
2159 int page;
2188 * Compute the chip, page and byte addresses for this block's
2192 page = block << (chip->phys_erase_shift - chip->page_shift);
2197 ret = nand_read_page_op(chip, page, mtd->writesize, &block_mark,