Lines Matching defs:page
300 * Now, the NAND chip with 2K page(data chunk is 512byte) shows below:
318 * P : the page size for BCH module.
321 * N : The chunk count of per page.
322 * M : the metasize of per page.
324 * P': the nand chip's page size.
335 * of page, and the delta is:
344 * view of the page is :
373 * N : The chunk count of per page.
375 * M : the metasize of per page.
459 * the physical block mark within the ECC-based view of the page.
461 * NAND chip with 2K page shows below:
472 * of page, and the delta is:
494 * within the ECC-based view of the page is still in the data chunk,
498 * physical block mark within the ECC-based view of the page:
878 * else we will use all the (page + OOB).
1131 * buffer of the real NAND page size when the gpmi_alloc_dma_buffer
1184 * the ECC engine applies its own view to the bits in the page, the
1254 * code in case we have bitflips in an erased page. As
1257 * at this point that we are reading an erased page and
1259 * ecc_strength bitflips. If this is a page with random
1321 int oob_required, int page)
1332 ret = nand_read_page_op(chip, page, 0, buf, geo->page_size);
1361 /* Fake a virtual small page for the subpage read */
1363 uint32_t len, uint8_t *buf, int page)
1387 * we have to read out the whole page.
1394 "page:%d, first:%d, last:%d, marker at:%d\n",
1395 page, first, last, marker_pos);
1396 return gpmi_ecc_read_page(chip, buf, 0, page);
1426 ret = nand_read_page_op(chip, page, col, buf, page_size);
1430 dev_dbg(this->dev, "page:%d(%d:%d)%d, chunk:(%d:%d), BCH PG size:%d\n",
1431 page, offs, len, col, first, n, page_size);
1439 int oob_required, int page)
1446 dev_dbg(this->dev, "ecc write page.\n");
1464 ret = nand_prog_page_op(chip, page, 0, buf, nfc_geo->page_size);
1481 * the physical page.
1488 * page, using the conventional definition of which bytes are data and which
1490 * in the page, without the distortions applied by our ECC engine.
1505 * Swapping | page and return it. It | |
1511 * | page and also the block | |
1519 * giving an accurate view of the actual, physical bytes in the page (we're
1524 * easy. When reading a page, for example, the NAND Flash MTD code calls our
1526 * ECC-based or raw view of the page is implicit in which function it calls
1529 static int gpmi_ecc_read_oob(struct nand_chip *chip, int page)
1539 ret = nand_read_page_op(chip, page, mtd->writesize, chip->oob_poi,
1551 ret = nand_read_page_op(chip, page, 0, chip->oob_poi, 1);
1559 static int gpmi_ecc_write_oob(struct nand_chip *chip, int page)
1572 return nand_prog_page_op(chip, page, mtd->writesize + of.offset,
1577 * This function reads a NAND page without involving the ECC engine (no HW
1583 * page into the provided buffers, which is why we're using nand_extract_bits().
1589 int oob_required, int page)
1604 ret = nand_read_page_op(chip, page, 0, tmp_buf,
1662 * This function writes a NAND page without involving the ECC engine (no HW
1668 * final page, which is why we're using nand_extract_bits().
1674 int oob_required, int page)
1698 * beginning of the page, as imposed by the GPMI layout.
1740 return nand_prog_page_op(chip, page, 0, tmp_buf,
1744 static int gpmi_ecc_read_oob_raw(struct nand_chip *chip, int page)
1746 return gpmi_ecc_read_page_raw(chip, NULL, 1, page);
1749 static int gpmi_ecc_write_oob_raw(struct nand_chip *chip, int page)
1751 return gpmi_ecc_write_page_raw(chip, NULL, 1, page);
1760 int column, page, chipnr;
1771 /* Shift to get page */
1772 page = (int)(ofs >> chip->page_shift);
1774 ret = nand_prog_page_op(chip, page, column, block_mark, 1);
1815 unsigned int page;
1831 /* Compute the page addresses. */
1832 page = stride * rom_geo->stride_size_in_pages;
1834 dev_dbg(dev, "Looking for a fingerprint in page 0x%x\n", page);
1838 * and starts in the 12th byte of the page.
1840 ret = nand_read_page_op(chip, page, 12, buffer,
1875 unsigned int page;
1906 /* Write the NCB fingerprint into the page buffer. */
1913 /* Compute the page addresses. */
1914 page = stride * rom_geo->stride_size_in_pages;
1916 /* Write the first page of the current stride. */
1917 dev_dbg(dev, "Writing an NCB fingerprint in page 0x%x\n", page);
1919 status = chip->ecc.write_page_raw(chip, buffer, 0, page);
1937 int page;
1966 * Compute the chip, page and byte addresses for this block's
1970 page = block << (chip->phys_erase_shift - chip->page_shift);
1975 ret = nand_read_page_op(chip, page, mtd->writesize, &block_mark,