Lines Matching refs:chip
109 struct nand_chip *chip = mtd_to_nand(mtd); in check_offs_len() local
113 if (ofs & ((1ULL << chip->phys_erase_shift) - 1)) { in check_offs_len()
119 if (len & ((1ULL << chip->phys_erase_shift) - 1)) { in check_offs_len()
135 struct nand_chip *chip = mtd_to_nand(mtd); in nand_release_device() local
138 chip->select_chip(mtd, -1); in nand_release_device()
149 struct nand_chip *chip = mtd_to_nand(mtd); in nand_read_byte() local
150 return readb(chip->IO_ADDR_R); in nand_read_byte()
162 struct nand_chip *chip = mtd_to_nand(mtd); in nand_read_byte16() local
163 return (uint8_t) cpu_to_le16(readw(chip->IO_ADDR_R)); in nand_read_byte16()
174 struct nand_chip *chip = mtd_to_nand(mtd); in nand_read_word() local
175 return readw(chip->IO_ADDR_R); in nand_read_word()
187 struct nand_chip *chip = mtd_to_nand(mtd); in nand_select_chip() local
191 chip->cmd_ctrl(mtd, NAND_CMD_NONE, 0 | NAND_CTRL_CHANGE); in nand_select_chip()
210 struct nand_chip *chip = mtd_to_nand(mtd); in nand_write_byte() local
212 chip->write_buf(mtd, &byte, 1); in nand_write_byte()
224 struct nand_chip *chip = mtd_to_nand(mtd); in nand_write_byte16() local
243 chip->write_buf(mtd, (uint8_t *)&word, 2); in nand_write_byte16()
289 struct nand_chip *chip = mtd_to_nand(mtd); in nand_write_buf() local
291 iowrite8_rep(chip->IO_ADDR_W, buf, len); in nand_write_buf()
304 struct nand_chip *chip = mtd_to_nand(mtd); in nand_read_buf() local
306 ioread8_rep(chip->IO_ADDR_R, buf, len); in nand_read_buf()
319 struct nand_chip *chip = mtd_to_nand(mtd); in nand_write_buf16() local
322 iowrite16_rep(chip->IO_ADDR_W, p, len >> 1); in nand_write_buf16()
335 struct nand_chip *chip = mtd_to_nand(mtd); in nand_read_buf16() local
338 ioread16_rep(chip->IO_ADDR_R, p, len >> 1); in nand_read_buf16()
351 struct nand_chip *chip = mtd_to_nand(mtd); in nand_block_bad() local
354 if (chip->bbt_options & NAND_BBT_SCANLASTPAGE) in nand_block_bad()
357 page = (int)(ofs >> chip->page_shift) & chip->pagemask; in nand_block_bad()
360 if (chip->options & NAND_BUSWIDTH_16) { in nand_block_bad()
361 chip->cmdfunc(mtd, NAND_CMD_READOOB, in nand_block_bad()
362 chip->badblockpos & 0xFE, page); in nand_block_bad()
363 bad = cpu_to_le16(chip->read_word(mtd)); in nand_block_bad()
364 if (chip->badblockpos & 0x1) in nand_block_bad()
369 chip->cmdfunc(mtd, NAND_CMD_READOOB, chip->badblockpos, in nand_block_bad()
371 bad = chip->read_byte(mtd); in nand_block_bad()
374 if (likely(chip->badblockbits == 8)) in nand_block_bad()
377 res = hweight8(bad) < chip->badblockbits; in nand_block_bad()
379 page = (int)(ofs >> chip->page_shift) & chip->pagemask; in nand_block_bad()
381 } while (!res && i < 2 && (chip->bbt_options & NAND_BBT_SCAN2NDPAGE)); in nand_block_bad()
397 struct nand_chip *chip = mtd_to_nand(mtd); in nand_default_block_markbad() local
404 ops.ooboffs = chip->badblockpos; in nand_default_block_markbad()
405 if (chip->options & NAND_BUSWIDTH_16) { in nand_default_block_markbad()
414 if (chip->bbt_options & NAND_BBT_SCANLASTPAGE) in nand_default_block_markbad()
423 } while ((chip->bbt_options & NAND_BBT_SCAN2NDPAGE) && i < 2); in nand_default_block_markbad()
447 struct nand_chip *chip = mtd_to_nand(mtd); in nand_block_markbad_lowlevel() local
450 if (!(chip->bbt_options & NAND_BBT_NO_OOB_BBM)) { in nand_block_markbad_lowlevel()
457 einfo.len = 1ULL << chip->phys_erase_shift; in nand_block_markbad_lowlevel()
462 ret = chip->block_markbad(mtd, ofs); in nand_block_markbad_lowlevel()
467 if (chip->bbt) { in nand_block_markbad_lowlevel()
488 struct nand_chip *chip = mtd_to_nand(mtd); in nand_check_wp() local
493 if (chip->options & NAND_BROKEN_XD) in nand_check_wp()
497 ret = nand_status_op(chip, &status); in nand_check_wp()
513 struct nand_chip *chip = mtd_to_nand(mtd); in nand_block_isreserved() local
515 if (!chip->bbt) in nand_block_isreserved()
532 struct nand_chip *chip = mtd_to_nand(mtd); in nand_block_checkbad() local
534 if (!(chip->options & NAND_SKIP_BBTSCAN) && in nand_block_checkbad()
535 !(chip->options & NAND_BBT_SCANNED)) { in nand_block_checkbad()
536 chip->options |= NAND_BBT_SCANNED; in nand_block_checkbad()
537 chip->scan_bbt(mtd); in nand_block_checkbad()
540 if (!chip->bbt) in nand_block_checkbad()
541 return chip->block_bad(mtd, ofs); in nand_block_checkbad()
555 struct nand_chip *chip = mtd_to_nand(mtd); in nand_wait_ready() local
562 if (chip->dev_ready) in nand_wait_ready()
563 if (chip->dev_ready(mtd)) in nand_wait_ready()
567 if (!chip->dev_ready(mtd)) in nand_wait_ready()
581 register struct nand_chip *chip = mtd_to_nand(mtd); in nand_wait_status_ready() local
590 ret = nand_read_data_op(chip, &status, sizeof(status), true); in nand_wait_status_ready()
613 register struct nand_chip *chip = mtd_to_nand(mtd); in nand_command() local
631 chip->cmd_ctrl(mtd, readcmd, ctrl); in nand_command()
634 chip->cmd_ctrl(mtd, command, ctrl); in nand_command()
641 if (chip->options & NAND_BUSWIDTH_16 && in nand_command()
644 chip->cmd_ctrl(mtd, column, ctrl); in nand_command()
648 chip->cmd_ctrl(mtd, page_addr, ctrl); in nand_command()
650 chip->cmd_ctrl(mtd, page_addr >> 8, ctrl); in nand_command()
651 if (chip->options & NAND_ROW_ADDR_3) in nand_command()
652 chip->cmd_ctrl(mtd, page_addr >> 16, ctrl); in nand_command()
654 chip->cmd_ctrl(mtd, NAND_CMD_NONE, NAND_NCE | NAND_CTRL_CHANGE); in nand_command()
672 if (chip->dev_ready) in nand_command()
674 udelay(chip->chip_delay); in nand_command()
675 chip->cmd_ctrl(mtd, NAND_CMD_STATUS, in nand_command()
677 chip->cmd_ctrl(mtd, in nand_command()
689 if (!chip->dev_ready) { in nand_command()
690 udelay(chip->chip_delay); in nand_command()
717 register struct nand_chip *chip = mtd_to_nand(mtd); in nand_command_lp() local
726 chip->cmd_ctrl(mtd, command, NAND_NCE | NAND_CLE | NAND_CTRL_CHANGE); in nand_command_lp()
734 if (chip->options & NAND_BUSWIDTH_16 && in nand_command_lp()
737 chip->cmd_ctrl(mtd, column, ctrl); in nand_command_lp()
739 chip->cmd_ctrl(mtd, column >> 8, ctrl); in nand_command_lp()
742 chip->cmd_ctrl(mtd, page_addr, ctrl); in nand_command_lp()
743 chip->cmd_ctrl(mtd, page_addr >> 8, in nand_command_lp()
745 if (chip->options & NAND_ROW_ADDR_3) in nand_command_lp()
746 chip->cmd_ctrl(mtd, page_addr >> 16, in nand_command_lp()
750 chip->cmd_ctrl(mtd, NAND_CMD_NONE, NAND_NCE | NAND_CTRL_CHANGE); in nand_command_lp()
770 if (chip->dev_ready) in nand_command_lp()
772 udelay(chip->chip_delay); in nand_command_lp()
773 chip->cmd_ctrl(mtd, NAND_CMD_STATUS, in nand_command_lp()
775 chip->cmd_ctrl(mtd, NAND_CMD_NONE, in nand_command_lp()
783 chip->cmd_ctrl(mtd, NAND_CMD_RNDOUTSTART, in nand_command_lp()
785 chip->cmd_ctrl(mtd, NAND_CMD_NONE, in nand_command_lp()
790 chip->cmd_ctrl(mtd, NAND_CMD_READSTART, in nand_command_lp()
792 chip->cmd_ctrl(mtd, NAND_CMD_NONE, in nand_command_lp()
801 if (!chip->dev_ready) { in nand_command_lp()
802 udelay(chip->chip_delay); in nand_command_lp()
824 static void panic_nand_get_device(struct nand_chip *chip, in panic_nand_get_device() argument
828 chip->controller->active = chip; in panic_nand_get_device()
829 chip->state = new_state; in panic_nand_get_device()
842 struct nand_chip *chip = mtd_to_nand(mtd); in nand_get_device() local
843 chip->state = new_state; in nand_get_device()
857 static void panic_nand_wait(struct mtd_info *mtd, struct nand_chip *chip, in panic_nand_wait() argument
862 if (chip->dev_ready) { in panic_nand_wait()
863 if (chip->dev_ready(mtd)) in panic_nand_wait()
869 ret = nand_read_data_op(chip, &status, sizeof(status), in panic_nand_wait()
888 static int nand_wait(struct mtd_info *mtd, struct nand_chip *chip) in nand_wait() argument
902 ret = nand_status_op(chip, NULL); in nand_wait()
911 if (chip->dev_ready) { in nand_wait()
912 if (chip->dev_ready(mtd)) in nand_wait()
915 ret = nand_read_data_op(chip, &status, in nand_wait()
926 ret = nand_read_data_op(chip, &status, sizeof(status), true); in nand_wait()
944 static int nand_reset_data_interface(struct nand_chip *chip, int chipnr) in nand_reset_data_interface() argument
946 struct mtd_info *mtd = nand_to_mtd(chip); in nand_reset_data_interface()
950 if (!chip->setup_data_interface) in nand_reset_data_interface()
968 ret = chip->setup_data_interface(mtd, chipnr, conf); in nand_reset_data_interface()
988 static int nand_setup_data_interface(struct nand_chip *chip, int chipnr) in nand_setup_data_interface() argument
990 struct mtd_info *mtd = nand_to_mtd(chip); in nand_setup_data_interface()
993 if (!chip->setup_data_interface || !chip->data_interface) in nand_setup_data_interface()
1000 if (chip->onfi_version) { in nand_setup_data_interface()
1002 chip->onfi_timing_mode_default, in nand_setup_data_interface()
1005 ret = chip->onfi_set_features(mtd, chip, in nand_setup_data_interface()
1012 ret = chip->setup_data_interface(mtd, chipnr, chip->data_interface); in nand_setup_data_interface()
1031 static int nand_init_data_interface(struct nand_chip *chip) in nand_init_data_interface() argument
1033 struct mtd_info *mtd = nand_to_mtd(chip); in nand_init_data_interface()
1036 if (!chip->setup_data_interface) in nand_init_data_interface()
1044 modes = onfi_get_async_timing_mode(chip); in nand_init_data_interface()
1046 if (!chip->onfi_timing_mode_default) in nand_init_data_interface()
1049 modes = GENMASK(chip->onfi_timing_mode_default, 0); in nand_init_data_interface()
1052 chip->data_interface = kzalloc(sizeof(*chip->data_interface), in nand_init_data_interface()
1054 if (!chip->data_interface) in nand_init_data_interface()
1058 ret = onfi_init_data_interface(chip, chip->data_interface, in nand_init_data_interface()
1064 ret = chip->setup_data_interface(mtd, in nand_init_data_interface()
1066 chip->data_interface); in nand_init_data_interface()
1068 chip->onfi_timing_mode_default = mode; in nand_init_data_interface()
1076 static void __maybe_unused nand_release_data_interface(struct nand_chip *chip) in nand_release_data_interface() argument
1078 kfree(chip->data_interface); in nand_release_data_interface()
1094 int nand_read_page_op(struct nand_chip *chip, unsigned int page, in nand_read_page_op() argument
1097 struct mtd_info *mtd = nand_to_mtd(chip); in nand_read_page_op()
1105 chip->cmdfunc(mtd, NAND_CMD_READ0, offset_in_page, page); in nand_read_page_op()
1107 chip->read_buf(mtd, buf, len); in nand_read_page_op()
1125 static int nand_read_param_page_op(struct nand_chip *chip, u8 page, void *buf, in nand_read_param_page_op() argument
1128 struct mtd_info *mtd = nand_to_mtd(chip); in nand_read_param_page_op()
1135 chip->cmdfunc(mtd, NAND_CMD_PARAM, page, -1); in nand_read_param_page_op()
1137 p[i] = chip->read_byte(mtd); in nand_read_param_page_op()
1155 int nand_change_read_column_op(struct nand_chip *chip, in nand_change_read_column_op() argument
1159 struct mtd_info *mtd = nand_to_mtd(chip); in nand_change_read_column_op()
1167 chip->cmdfunc(mtd, NAND_CMD_RNDOUT, offset_in_page, -1); in nand_change_read_column_op()
1169 chip->read_buf(mtd, buf, len); in nand_change_read_column_op()
1188 int nand_read_oob_op(struct nand_chip *chip, unsigned int page, in nand_read_oob_op() argument
1191 struct mtd_info *mtd = nand_to_mtd(chip); in nand_read_oob_op()
1199 chip->cmdfunc(mtd, NAND_CMD_READOOB, offset_in_oob, page); in nand_read_oob_op()
1201 chip->read_buf(mtd, buf, len); in nand_read_oob_op()
1220 int nand_prog_page_begin_op(struct nand_chip *chip, unsigned int page, in nand_prog_page_begin_op() argument
1224 struct mtd_info *mtd = nand_to_mtd(chip); in nand_prog_page_begin_op()
1232 chip->cmdfunc(mtd, NAND_CMD_SEQIN, offset_in_page, page); in nand_prog_page_begin_op()
1235 chip->write_buf(mtd, buf, len); in nand_prog_page_begin_op()
1250 int nand_prog_page_end_op(struct nand_chip *chip) in nand_prog_page_end_op() argument
1252 struct mtd_info *mtd = nand_to_mtd(chip); in nand_prog_page_end_op()
1255 chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1); in nand_prog_page_end_op()
1257 status = chip->waitfunc(mtd, chip); in nand_prog_page_end_op()
1278 int nand_prog_page_op(struct nand_chip *chip, unsigned int page, in nand_prog_page_op() argument
1282 struct mtd_info *mtd = nand_to_mtd(chip); in nand_prog_page_op()
1291 chip->cmdfunc(mtd, NAND_CMD_SEQIN, offset_in_page, page); in nand_prog_page_op()
1292 chip->write_buf(mtd, buf, len); in nand_prog_page_op()
1293 chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1); in nand_prog_page_op()
1295 status = chip->waitfunc(mtd, chip); in nand_prog_page_op()
1316 int nand_change_write_column_op(struct nand_chip *chip, in nand_change_write_column_op() argument
1321 struct mtd_info *mtd = nand_to_mtd(chip); in nand_change_write_column_op()
1329 chip->cmdfunc(mtd, NAND_CMD_RNDIN, offset_in_page, -1); in nand_change_write_column_op()
1331 chip->write_buf(mtd, buf, len); in nand_change_write_column_op()
1350 int nand_readid_op(struct nand_chip *chip, u8 addr, void *buf, in nand_readid_op() argument
1353 struct mtd_info *mtd = nand_to_mtd(chip); in nand_readid_op()
1360 chip->cmdfunc(mtd, NAND_CMD_READID, addr, -1); in nand_readid_op()
1363 id[i] = chip->read_byte(mtd); in nand_readid_op()
1380 int nand_status_op(struct nand_chip *chip, u8 *status) in nand_status_op() argument
1382 struct mtd_info *mtd = nand_to_mtd(chip); in nand_status_op()
1384 chip->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1); in nand_status_op()
1386 *status = chip->read_byte(mtd); in nand_status_op()
1403 int nand_exit_status_op(struct nand_chip *chip) in nand_exit_status_op() argument
1405 struct mtd_info *mtd = nand_to_mtd(chip); in nand_exit_status_op()
1407 chip->cmdfunc(mtd, NAND_CMD_READ0, -1, -1); in nand_exit_status_op()
1424 int nand_erase_op(struct nand_chip *chip, unsigned int eraseblock) in nand_erase_op() argument
1426 struct mtd_info *mtd = nand_to_mtd(chip); in nand_erase_op()
1428 (chip->phys_erase_shift - chip->page_shift); in nand_erase_op()
1431 chip->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page); in nand_erase_op()
1432 chip->cmdfunc(mtd, NAND_CMD_ERASE2, -1, -1); in nand_erase_op()
1434 status = chip->waitfunc(mtd, chip); in nand_erase_op()
1457 static int nand_set_features_op(struct nand_chip *chip, u8 feature, in nand_set_features_op() argument
1460 struct mtd_info *mtd = nand_to_mtd(chip); in nand_set_features_op()
1464 chip->cmdfunc(mtd, NAND_CMD_SET_FEATURES, feature, -1); in nand_set_features_op()
1466 chip->write_byte(mtd, params[i]); in nand_set_features_op()
1468 status = chip->waitfunc(mtd, chip); in nand_set_features_op()
1487 static int nand_get_features_op(struct nand_chip *chip, u8 feature, in nand_get_features_op() argument
1490 struct mtd_info *mtd = nand_to_mtd(chip); in nand_get_features_op()
1494 chip->cmdfunc(mtd, NAND_CMD_GET_FEATURES, feature, -1); in nand_get_features_op()
1496 params[i] = chip->read_byte(mtd); in nand_get_features_op()
1511 int nand_reset_op(struct nand_chip *chip) in nand_reset_op() argument
1513 struct mtd_info *mtd = nand_to_mtd(chip); in nand_reset_op()
1515 chip->cmdfunc(mtd, NAND_CMD_RESET, -1, -1); in nand_reset_op()
1534 int nand_read_data_op(struct nand_chip *chip, void *buf, unsigned int len, in nand_read_data_op() argument
1537 struct mtd_info *mtd = nand_to_mtd(chip); in nand_read_data_op()
1547 p[i] = chip->read_byte(mtd); in nand_read_data_op()
1549 chip->read_buf(mtd, buf, len); in nand_read_data_op()
1569 int nand_write_data_op(struct nand_chip *chip, const void *buf, in nand_write_data_op() argument
1572 struct mtd_info *mtd = nand_to_mtd(chip); in nand_write_data_op()
1582 chip->write_byte(mtd, p[i]); in nand_write_data_op()
1584 chip->write_buf(mtd, buf, len); in nand_write_data_op()
1598 int nand_reset(struct nand_chip *chip, int chipnr) in nand_reset() argument
1600 struct mtd_info *mtd = nand_to_mtd(chip); in nand_reset()
1603 ret = nand_reset_data_interface(chip, chipnr); in nand_reset()
1611 chip->select_chip(mtd, chipnr); in nand_reset()
1612 ret = nand_reset_op(chip); in nand_reset()
1613 chip->select_chip(mtd, -1); in nand_reset()
1617 chip->select_chip(mtd, chipnr); in nand_reset()
1618 ret = nand_setup_data_interface(chip, chipnr); in nand_reset()
1619 chip->select_chip(mtd, -1); in nand_reset()
1763 static int nand_read_page_raw(struct mtd_info *mtd, struct nand_chip *chip, in nand_read_page_raw() argument
1768 ret = nand_read_data_op(chip, buf, mtd->writesize, false); in nand_read_page_raw()
1773 ret = nand_read_data_op(chip, chip->oob_poi, mtd->oobsize, in nand_read_page_raw()
1793 struct nand_chip *chip, uint8_t *buf, in nand_read_page_raw_syndrome() argument
1796 int eccsize = chip->ecc.size; in nand_read_page_raw_syndrome()
1797 int eccbytes = chip->ecc.bytes; in nand_read_page_raw_syndrome()
1798 uint8_t *oob = chip->oob_poi; in nand_read_page_raw_syndrome()
1801 for (steps = chip->ecc.steps; steps > 0; steps--) { in nand_read_page_raw_syndrome()
1802 ret = nand_read_data_op(chip, buf, eccsize, false); in nand_read_page_raw_syndrome()
1808 if (chip->ecc.prepad) { in nand_read_page_raw_syndrome()
1809 ret = nand_read_data_op(chip, oob, chip->ecc.prepad, in nand_read_page_raw_syndrome()
1814 oob += chip->ecc.prepad; in nand_read_page_raw_syndrome()
1817 ret = nand_read_data_op(chip, oob, eccbytes, false); in nand_read_page_raw_syndrome()
1823 if (chip->ecc.postpad) { in nand_read_page_raw_syndrome()
1824 ret = nand_read_data_op(chip, oob, chip->ecc.postpad, in nand_read_page_raw_syndrome()
1829 oob += chip->ecc.postpad; in nand_read_page_raw_syndrome()
1833 size = mtd->oobsize - (oob - chip->oob_poi); in nand_read_page_raw_syndrome()
1835 ret = nand_read_data_op(chip, oob, size, false); in nand_read_page_raw_syndrome()
1851 static int nand_read_page_swecc(struct mtd_info *mtd, struct nand_chip *chip, in nand_read_page_swecc() argument
1854 int i, eccsize = chip->ecc.size; in nand_read_page_swecc()
1855 int eccbytes = chip->ecc.bytes; in nand_read_page_swecc()
1856 int eccsteps = chip->ecc.steps; in nand_read_page_swecc()
1858 uint8_t *ecc_calc = chip->buffers->ecccalc; in nand_read_page_swecc()
1859 uint8_t *ecc_code = chip->buffers->ecccode; in nand_read_page_swecc()
1860 uint32_t *eccpos = chip->ecc.layout->eccpos; in nand_read_page_swecc()
1863 chip->ecc.read_page_raw(mtd, chip, buf, 1, page); in nand_read_page_swecc()
1866 chip->ecc.calculate(mtd, p, &ecc_calc[i]); in nand_read_page_swecc()
1868 for (i = 0; i < chip->ecc.total; i++) in nand_read_page_swecc()
1869 ecc_code[i] = chip->oob_poi[eccpos[i]]; in nand_read_page_swecc()
1871 eccsteps = chip->ecc.steps; in nand_read_page_swecc()
1877 stat = chip->ecc.correct(mtd, p, &ecc_code[i], &ecc_calc[i]); in nand_read_page_swecc()
1897 static int nand_read_subpage(struct mtd_info *mtd, struct nand_chip *chip, in nand_read_subpage() argument
1902 uint32_t *eccpos = chip->ecc.layout->eccpos; in nand_read_subpage()
1906 int busw = (chip->options & NAND_BUSWIDTH_16) ? 2 : 1; in nand_read_subpage()
1912 start_step = data_offs / chip->ecc.size; in nand_read_subpage()
1913 end_step = (data_offs + readlen - 1) / chip->ecc.size; in nand_read_subpage()
1915 index = start_step * chip->ecc.bytes; in nand_read_subpage()
1918 datafrag_len = num_steps * chip->ecc.size; in nand_read_subpage()
1919 eccfrag_len = num_steps * chip->ecc.bytes; in nand_read_subpage()
1921 data_col_addr = start_step * chip->ecc.size; in nand_read_subpage()
1924 chip->cmdfunc(mtd, NAND_CMD_RNDOUT, data_col_addr, -1); in nand_read_subpage()
1927 ret = nand_read_data_op(chip, p, datafrag_len, false); in nand_read_subpage()
1932 for (i = 0; i < eccfrag_len ; i += chip->ecc.bytes, p += chip->ecc.size) in nand_read_subpage()
1933 chip->ecc.calculate(mtd, p, &chip->buffers->ecccalc[i]); in nand_read_subpage()
1946 ret = nand_change_read_column_op(chip, mtd->writesize, in nand_read_subpage()
1947 chip->oob_poi, mtd->oobsize, in nand_read_subpage()
1960 if (eccpos[index + (num_steps * chip->ecc.bytes)] & (busw - 1)) in nand_read_subpage()
1963 ret = nand_change_read_column_op(chip, in nand_read_subpage()
1965 &chip->oob_poi[aligned_pos], in nand_read_subpage()
1972 chip->buffers->ecccode[i] = chip->oob_poi[eccpos[i + index]]; in nand_read_subpage()
1975 for (i = 0; i < eccfrag_len ; i += chip->ecc.bytes, p += chip->ecc.size) { in nand_read_subpage()
1978 stat = chip->ecc.correct(mtd, p, in nand_read_subpage()
1979 &chip->buffers->ecccode[i], &chip->buffers->ecccalc[i]); in nand_read_subpage()
1981 (chip->ecc.options & NAND_ECC_GENERIC_ERASED_CHECK)) { in nand_read_subpage()
1983 stat = nand_check_erased_ecc_chunk(p, chip->ecc.size, in nand_read_subpage()
1984 &chip->buffers->ecccode[i], in nand_read_subpage()
1985 chip->ecc.bytes, in nand_read_subpage()
1987 chip->ecc.strength); in nand_read_subpage()
2010 static int nand_read_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip, in nand_read_page_hwecc() argument
2013 int i, eccsize = chip->ecc.size; in nand_read_page_hwecc()
2014 int eccbytes = chip->ecc.bytes; in nand_read_page_hwecc()
2015 int eccsteps = chip->ecc.steps; in nand_read_page_hwecc()
2017 uint8_t *ecc_calc = chip->buffers->ecccalc; in nand_read_page_hwecc()
2018 uint8_t *ecc_code = chip->buffers->ecccode; in nand_read_page_hwecc()
2019 uint32_t *eccpos = chip->ecc.layout->eccpos; in nand_read_page_hwecc()
2024 chip->ecc.hwctl(mtd, NAND_ECC_READ); in nand_read_page_hwecc()
2026 ret = nand_read_data_op(chip, p, eccsize, false); in nand_read_page_hwecc()
2030 chip->ecc.calculate(mtd, p, &ecc_calc[i]); in nand_read_page_hwecc()
2033 ret = nand_read_data_op(chip, chip->oob_poi, mtd->oobsize, false); in nand_read_page_hwecc()
2037 for (i = 0; i < chip->ecc.total; i++) in nand_read_page_hwecc()
2038 ecc_code[i] = chip->oob_poi[eccpos[i]]; in nand_read_page_hwecc()
2040 eccsteps = chip->ecc.steps; in nand_read_page_hwecc()
2046 stat = chip->ecc.correct(mtd, p, &ecc_code[i], &ecc_calc[i]); in nand_read_page_hwecc()
2048 (chip->ecc.options & NAND_ECC_GENERIC_ERASED_CHECK)) { in nand_read_page_hwecc()
2053 chip->ecc.strength); in nand_read_page_hwecc()
2081 struct nand_chip *chip, uint8_t *buf, int oob_required, int page) in nand_read_page_hwecc_oob_first() argument
2083 int i, eccsize = chip->ecc.size; in nand_read_page_hwecc_oob_first()
2084 int eccbytes = chip->ecc.bytes; in nand_read_page_hwecc_oob_first()
2085 int eccsteps = chip->ecc.steps; in nand_read_page_hwecc_oob_first()
2087 uint8_t *ecc_code = chip->buffers->ecccode; in nand_read_page_hwecc_oob_first()
2088 uint32_t *eccpos = chip->ecc.layout->eccpos; in nand_read_page_hwecc_oob_first()
2089 uint8_t *ecc_calc = chip->buffers->ecccalc; in nand_read_page_hwecc_oob_first()
2094 ret = nand_read_oob_op(chip, page, 0, chip->oob_poi, mtd->oobsize); in nand_read_page_hwecc_oob_first()
2098 ret = nand_read_page_op(chip, page, 0, NULL, 0); in nand_read_page_hwecc_oob_first()
2102 for (i = 0; i < chip->ecc.total; i++) in nand_read_page_hwecc_oob_first()
2103 ecc_code[i] = chip->oob_poi[eccpos[i]]; in nand_read_page_hwecc_oob_first()
2108 chip->ecc.hwctl(mtd, NAND_ECC_READ); in nand_read_page_hwecc_oob_first()
2110 ret = nand_read_data_op(chip, p, eccsize, false); in nand_read_page_hwecc_oob_first()
2114 chip->ecc.calculate(mtd, p, &ecc_calc[i]); in nand_read_page_hwecc_oob_first()
2116 stat = chip->ecc.correct(mtd, p, &ecc_code[i], NULL); in nand_read_page_hwecc_oob_first()
2118 (chip->ecc.options & NAND_ECC_GENERIC_ERASED_CHECK)) { in nand_read_page_hwecc_oob_first()
2123 chip->ecc.strength); in nand_read_page_hwecc_oob_first()
2147 static int nand_read_page_syndrome(struct mtd_info *mtd, struct nand_chip *chip, in nand_read_page_syndrome() argument
2150 int ret, i, eccsize = chip->ecc.size; in nand_read_page_syndrome()
2151 int eccbytes = chip->ecc.bytes; in nand_read_page_syndrome()
2152 int eccsteps = chip->ecc.steps; in nand_read_page_syndrome()
2153 int eccpadbytes = eccbytes + chip->ecc.prepad + chip->ecc.postpad; in nand_read_page_syndrome()
2155 uint8_t *oob = chip->oob_poi; in nand_read_page_syndrome()
2161 chip->ecc.hwctl(mtd, NAND_ECC_READ); in nand_read_page_syndrome()
2163 ret = nand_read_data_op(chip, p, eccsize, false); in nand_read_page_syndrome()
2167 if (chip->ecc.prepad) { in nand_read_page_syndrome()
2168 ret = nand_read_data_op(chip, oob, chip->ecc.prepad, in nand_read_page_syndrome()
2173 oob += chip->ecc.prepad; in nand_read_page_syndrome()
2176 chip->ecc.hwctl(mtd, NAND_ECC_READSYN); in nand_read_page_syndrome()
2178 ret = nand_read_data_op(chip, oob, eccbytes, false); in nand_read_page_syndrome()
2182 stat = chip->ecc.correct(mtd, p, oob, NULL); in nand_read_page_syndrome()
2186 if (chip->ecc.postpad) { in nand_read_page_syndrome()
2187 ret = nand_read_data_op(chip, oob, chip->ecc.postpad, in nand_read_page_syndrome()
2192 oob += chip->ecc.postpad; in nand_read_page_syndrome()
2196 (chip->ecc.options & NAND_ECC_GENERIC_ERASED_CHECK)) { in nand_read_page_syndrome()
2198 stat = nand_check_erased_ecc_chunk(p, chip->ecc.size, in nand_read_page_syndrome()
2202 chip->ecc.strength); in nand_read_page_syndrome()
2214 i = mtd->oobsize - (oob - chip->oob_poi); in nand_read_page_syndrome()
2216 ret = nand_read_data_op(chip, oob, i, false); in nand_read_page_syndrome()
2231 static uint8_t *nand_transfer_oob(struct nand_chip *chip, uint8_t *oob, in nand_transfer_oob() argument
2238 memcpy(oob, chip->oob_poi + ops->ooboffs, len); in nand_transfer_oob()
2242 struct nand_oobfree *free = chip->ecc.layout->oobfree; in nand_transfer_oob()
2261 memcpy(oob, chip->oob_poi + boffs, bytes); in nand_transfer_oob()
2283 struct nand_chip *chip = mtd_to_nand(mtd); in nand_setup_read_retry() local
2287 if (retry_mode >= chip->read_retries) in nand_setup_read_retry()
2290 if (!chip->setup_read_retry) in nand_setup_read_retry()
2293 return chip->setup_read_retry(mtd, retry_mode); in nand_setup_read_retry()
2308 struct nand_chip *chip = mtd_to_nand(mtd); in nand_do_read_ops() local
2320 chipnr = (int)(from >> chip->chip_shift); in nand_do_read_ops()
2321 chip->select_chip(mtd, chipnr); in nand_do_read_ops()
2323 realpage = (int)(from >> chip->page_shift); in nand_do_read_ops()
2324 page = realpage & chip->pagemask; in nand_do_read_ops()
2341 else if (chip->options & NAND_USE_BOUNCE_BUFFER) in nand_do_read_ops()
2343 chip->buf_align); in nand_do_read_ops()
2348 if (realpage != chip->pagebuf || oob) { in nand_do_read_ops()
2349 bufpoi = use_bufpoi ? chip->buffers->databuf : buf; in nand_do_read_ops()
2356 if (nand_standard_page_accessors(&chip->ecc)) { in nand_do_read_ops()
2357 ret = nand_read_page_op(chip, page, 0, NULL, 0); in nand_do_read_ops()
2367 ret = chip->ecc.read_page_raw(mtd, chip, bufpoi, in nand_do_read_ops()
2370 else if (!aligned && NAND_HAS_SUBPAGE_READ(chip) && in nand_do_read_ops()
2372 ret = chip->ecc.read_subpage(mtd, chip, in nand_do_read_ops()
2376 ret = chip->ecc.read_page(mtd, chip, bufpoi, in nand_do_read_ops()
2381 chip->pagebuf = -1; in nand_do_read_ops()
2389 if (!NAND_HAS_SUBPAGE_READ(chip) && !oob && in nand_do_read_ops()
2392 chip->pagebuf = realpage; in nand_do_read_ops()
2393 chip->pagebuf_bitflips = ret; in nand_do_read_ops()
2396 chip->pagebuf = -1; in nand_do_read_ops()
2398 memcpy(buf, chip->buffers->databuf + col, bytes); in nand_do_read_ops()
2405 oob = nand_transfer_oob(chip, in nand_do_read_ops()
2411 if (chip->options & NAND_NEED_READRDY) { in nand_do_read_ops()
2413 if (!chip->dev_ready) in nand_do_read_ops()
2414 udelay(chip->chip_delay); in nand_do_read_ops()
2420 if (retry_mode + 1 < chip->read_retries) { in nand_do_read_ops()
2438 memcpy(buf, chip->buffers->databuf + col, bytes); in nand_do_read_ops()
2441 chip->pagebuf_bitflips); in nand_do_read_ops()
2462 page = realpage & chip->pagemask; in nand_do_read_ops()
2466 chip->select_chip(mtd, -1); in nand_do_read_ops()
2467 chip->select_chip(mtd, chipnr); in nand_do_read_ops()
2470 chip->select_chip(mtd, -1); in nand_do_read_ops()
2491 static int nand_read_oob_std(struct mtd_info *mtd, struct nand_chip *chip, in nand_read_oob_std() argument
2494 return nand_read_oob_op(chip, page, 0, chip->oob_poi, mtd->oobsize); in nand_read_oob_std()
2504 static int nand_read_oob_syndrome(struct mtd_info *mtd, struct nand_chip *chip, in nand_read_oob_syndrome() argument
2508 int chunk = chip->ecc.bytes + chip->ecc.prepad + chip->ecc.postpad; in nand_read_oob_syndrome()
2509 int eccsize = chip->ecc.size; in nand_read_oob_syndrome()
2510 uint8_t *bufpoi = chip->oob_poi; in nand_read_oob_syndrome()
2513 ret = nand_read_page_op(chip, page, chip->ecc.size, NULL, 0); in nand_read_oob_syndrome()
2517 for (i = 0; i < chip->ecc.steps; i++) { in nand_read_oob_syndrome()
2523 ret = nand_change_read_column_op(chip, pos, in nand_read_oob_syndrome()
2527 ret = nand_read_page_op(chip, page, pos, NULL, in nand_read_oob_syndrome()
2536 ret = nand_read_data_op(chip, bufpoi, toread, false); in nand_read_oob_syndrome()
2544 ret = nand_read_data_op(chip, bufpoi, length, false); in nand_read_oob_syndrome()
2558 static int nand_write_oob_std(struct mtd_info *mtd, struct nand_chip *chip, in nand_write_oob_std() argument
2561 return nand_prog_page_op(chip, page, mtd->writesize, chip->oob_poi, in nand_write_oob_std()
2573 struct nand_chip *chip, int page) in nand_write_oob_syndrome() argument
2575 int chunk = chip->ecc.bytes + chip->ecc.prepad + chip->ecc.postpad; in nand_write_oob_syndrome()
2576 int eccsize = chip->ecc.size, length = mtd->oobsize; in nand_write_oob_syndrome()
2577 int ret, i, len, pos, sndcmd = 0, steps = chip->ecc.steps; in nand_write_oob_syndrome()
2578 const uint8_t *bufpoi = chip->oob_poi; in nand_write_oob_syndrome()
2585 if (!chip->ecc.prepad && !chip->ecc.postpad) { in nand_write_oob_syndrome()
2591 ret = nand_prog_page_begin_op(chip, page, pos, NULL, 0); in nand_write_oob_syndrome()
2604 ret = nand_write_data_op(chip, &fill, in nand_write_oob_syndrome()
2613 ret = nand_change_write_column_op(chip, pos, in nand_write_oob_syndrome()
2623 ret = nand_write_data_op(chip, bufpoi, len, false); in nand_write_oob_syndrome()
2631 ret = nand_write_data_op(chip, bufpoi, length, false); in nand_write_oob_syndrome()
2636 return nand_prog_page_end_op(chip); in nand_write_oob_syndrome()
2651 struct nand_chip *chip = mtd_to_nand(mtd); in nand_do_read_oob() local
2673 ops->ooboffs + readlen > ((mtd->size >> chip->page_shift) - in nand_do_read_oob()
2674 (from >> chip->page_shift)) * len)) { in nand_do_read_oob()
2680 chipnr = (int)(from >> chip->chip_shift); in nand_do_read_oob()
2681 chip->select_chip(mtd, chipnr); in nand_do_read_oob()
2684 realpage = (int)(from >> chip->page_shift); in nand_do_read_oob()
2685 page = realpage & chip->pagemask; in nand_do_read_oob()
2691 ret = chip->ecc.read_oob_raw(mtd, chip, page); in nand_do_read_oob()
2693 ret = chip->ecc.read_oob(mtd, chip, page); in nand_do_read_oob()
2699 buf = nand_transfer_oob(chip, buf, ops, len); in nand_do_read_oob()
2701 if (chip->options & NAND_NEED_READRDY) { in nand_do_read_oob()
2703 if (!chip->dev_ready) in nand_do_read_oob()
2704 udelay(chip->chip_delay); in nand_do_read_oob()
2716 page = realpage & chip->pagemask; in nand_do_read_oob()
2720 chip->select_chip(mtd, -1); in nand_do_read_oob()
2721 chip->select_chip(mtd, chipnr); in nand_do_read_oob()
2724 chip->select_chip(mtd, -1); in nand_do_read_oob()
2792 static int nand_write_page_raw(struct mtd_info *mtd, struct nand_chip *chip, in nand_write_page_raw() argument
2797 ret = nand_write_data_op(chip, buf, mtd->writesize, false); in nand_write_page_raw()
2802 ret = nand_write_data_op(chip, chip->oob_poi, mtd->oobsize, in nand_write_page_raw()
2822 struct nand_chip *chip, in nand_write_page_raw_syndrome() argument
2826 int eccsize = chip->ecc.size; in nand_write_page_raw_syndrome()
2827 int eccbytes = chip->ecc.bytes; in nand_write_page_raw_syndrome()
2828 uint8_t *oob = chip->oob_poi; in nand_write_page_raw_syndrome()
2831 for (steps = chip->ecc.steps; steps > 0; steps--) { in nand_write_page_raw_syndrome()
2832 ret = nand_write_data_op(chip, buf, eccsize, false); in nand_write_page_raw_syndrome()
2838 if (chip->ecc.prepad) { in nand_write_page_raw_syndrome()
2839 ret = nand_write_data_op(chip, oob, chip->ecc.prepad, in nand_write_page_raw_syndrome()
2844 oob += chip->ecc.prepad; in nand_write_page_raw_syndrome()
2847 ret = nand_write_data_op(chip, oob, eccbytes, false); in nand_write_page_raw_syndrome()
2853 if (chip->ecc.postpad) { in nand_write_page_raw_syndrome()
2854 ret = nand_write_data_op(chip, oob, chip->ecc.postpad, in nand_write_page_raw_syndrome()
2859 oob += chip->ecc.postpad; in nand_write_page_raw_syndrome()
2863 size = mtd->oobsize - (oob - chip->oob_poi); in nand_write_page_raw_syndrome()
2865 ret = nand_write_data_op(chip, oob, size, false); in nand_write_page_raw_syndrome()
2880 static int nand_write_page_swecc(struct mtd_info *mtd, struct nand_chip *chip, in nand_write_page_swecc() argument
2884 int i, eccsize = chip->ecc.size; in nand_write_page_swecc()
2885 int eccbytes = chip->ecc.bytes; in nand_write_page_swecc()
2886 int eccsteps = chip->ecc.steps; in nand_write_page_swecc()
2887 uint8_t *ecc_calc = chip->buffers->ecccalc; in nand_write_page_swecc()
2889 uint32_t *eccpos = chip->ecc.layout->eccpos; in nand_write_page_swecc()
2893 chip->ecc.calculate(mtd, p, &ecc_calc[i]); in nand_write_page_swecc()
2895 for (i = 0; i < chip->ecc.total; i++) in nand_write_page_swecc()
2896 chip->oob_poi[eccpos[i]] = ecc_calc[i]; in nand_write_page_swecc()
2898 return chip->ecc.write_page_raw(mtd, chip, buf, 1, page); in nand_write_page_swecc()
2909 static int nand_write_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip, in nand_write_page_hwecc() argument
2913 int i, eccsize = chip->ecc.size; in nand_write_page_hwecc()
2914 int eccbytes = chip->ecc.bytes; in nand_write_page_hwecc()
2915 int eccsteps = chip->ecc.steps; in nand_write_page_hwecc()
2916 uint8_t *ecc_calc = chip->buffers->ecccalc; in nand_write_page_hwecc()
2918 uint32_t *eccpos = chip->ecc.layout->eccpos; in nand_write_page_hwecc()
2922 chip->ecc.hwctl(mtd, NAND_ECC_WRITE); in nand_write_page_hwecc()
2924 ret = nand_write_data_op(chip, p, eccsize, false); in nand_write_page_hwecc()
2928 chip->ecc.calculate(mtd, p, &ecc_calc[i]); in nand_write_page_hwecc()
2931 for (i = 0; i < chip->ecc.total; i++) in nand_write_page_hwecc()
2932 chip->oob_poi[eccpos[i]] = ecc_calc[i]; in nand_write_page_hwecc()
2934 ret = nand_write_data_op(chip, chip->oob_poi, mtd->oobsize, false); in nand_write_page_hwecc()
2953 struct nand_chip *chip, uint32_t offset, in nand_write_subpage_hwecc() argument
2957 uint8_t *oob_buf = chip->oob_poi; in nand_write_subpage_hwecc()
2958 uint8_t *ecc_calc = chip->buffers->ecccalc; in nand_write_subpage_hwecc()
2959 int ecc_size = chip->ecc.size; in nand_write_subpage_hwecc()
2960 int ecc_bytes = chip->ecc.bytes; in nand_write_subpage_hwecc()
2961 int ecc_steps = chip->ecc.steps; in nand_write_subpage_hwecc()
2962 uint32_t *eccpos = chip->ecc.layout->eccpos; in nand_write_subpage_hwecc()
2971 chip->ecc.hwctl(mtd, NAND_ECC_WRITE); in nand_write_subpage_hwecc()
2974 ret = nand_write_data_op(chip, buf, ecc_size, false); in nand_write_subpage_hwecc()
2982 chip->ecc.calculate(mtd, buf, ecc_calc); in nand_write_subpage_hwecc()
2996 ecc_calc = chip->buffers->ecccalc; in nand_write_subpage_hwecc()
2997 for (i = 0; i < chip->ecc.total; i++) in nand_write_subpage_hwecc()
2998 chip->oob_poi[eccpos[i]] = ecc_calc[i]; in nand_write_subpage_hwecc()
3001 ret = nand_write_data_op(chip, chip->oob_poi, mtd->oobsize, false); in nand_write_subpage_hwecc()
3021 struct nand_chip *chip, in nand_write_page_syndrome() argument
3025 int i, eccsize = chip->ecc.size; in nand_write_page_syndrome()
3026 int eccbytes = chip->ecc.bytes; in nand_write_page_syndrome()
3027 int eccsteps = chip->ecc.steps; in nand_write_page_syndrome()
3029 uint8_t *oob = chip->oob_poi; in nand_write_page_syndrome()
3033 chip->ecc.hwctl(mtd, NAND_ECC_WRITE); in nand_write_page_syndrome()
3035 ret = nand_write_data_op(chip, p, eccsize, false); in nand_write_page_syndrome()
3039 if (chip->ecc.prepad) { in nand_write_page_syndrome()
3040 ret = nand_write_data_op(chip, oob, chip->ecc.prepad, in nand_write_page_syndrome()
3045 oob += chip->ecc.prepad; in nand_write_page_syndrome()
3048 chip->ecc.calculate(mtd, p, oob); in nand_write_page_syndrome()
3050 ret = nand_write_data_op(chip, oob, eccbytes, false); in nand_write_page_syndrome()
3056 if (chip->ecc.postpad) { in nand_write_page_syndrome()
3057 ret = nand_write_data_op(chip, oob, chip->ecc.postpad, in nand_write_page_syndrome()
3062 oob += chip->ecc.postpad; in nand_write_page_syndrome()
3067 i = mtd->oobsize - (oob - chip->oob_poi); in nand_write_page_syndrome()
3069 ret = nand_write_data_op(chip, oob, i, false); in nand_write_page_syndrome()
3088 static int nand_write_page(struct mtd_info *mtd, struct nand_chip *chip, in nand_write_page() argument
3094 if (!(chip->options & NAND_NO_SUBPAGE_WRITE) && in nand_write_page()
3095 chip->ecc.write_subpage) in nand_write_page()
3100 if (nand_standard_page_accessors(&chip->ecc)) { in nand_write_page()
3101 status = nand_prog_page_begin_op(chip, page, 0, NULL, 0); in nand_write_page()
3107 status = chip->ecc.write_page_raw(mtd, chip, buf, in nand_write_page()
3110 status = chip->ecc.write_subpage(mtd, chip, offset, data_len, in nand_write_page()
3113 status = chip->ecc.write_page(mtd, chip, buf, oob_required, in nand_write_page()
3119 if (nand_standard_page_accessors(&chip->ecc)) in nand_write_page()
3120 return nand_prog_page_end_op(chip); in nand_write_page()
3135 struct nand_chip *chip = mtd_to_nand(mtd); in nand_fill_oob() local
3141 memset(chip->oob_poi, 0xff, mtd->oobsize); in nand_fill_oob()
3147 memcpy(chip->oob_poi + ops->ooboffs, oob, len); in nand_fill_oob()
3151 struct nand_oobfree *free = chip->ecc.layout->oobfree; in nand_fill_oob()
3170 memcpy(chip->oob_poi + boffs, oob, bytes); in nand_fill_oob()
3181 #define NOTALIGNED(x) ((x & (chip->subpagesize - 1)) != 0)
3195 struct nand_chip *chip = mtd_to_nand(mtd); in nand_do_write_ops() local
3219 chipnr = (int)(to >> chip->chip_shift); in nand_do_write_ops()
3220 chip->select_chip(mtd, chipnr); in nand_do_write_ops()
3228 realpage = (int)(to >> chip->page_shift); in nand_do_write_ops()
3229 page = realpage & chip->pagemask; in nand_do_write_ops()
3232 if (to <= ((loff_t)chip->pagebuf << chip->page_shift) && in nand_do_write_ops()
3233 ((loff_t)chip->pagebuf << chip->page_shift) < (to + ops->len)) in nand_do_write_ops()
3234 chip->pagebuf = -1; in nand_do_write_ops()
3250 else if (chip->options & NAND_USE_BOUNCE_BUFFER) in nand_do_write_ops()
3252 chip->buf_align); in nand_do_write_ops()
3263 chip->pagebuf = -1; in nand_do_write_ops()
3264 memset(chip->buffers->databuf, 0xff, mtd->writesize); in nand_do_write_ops()
3265 memcpy(&chip->buffers->databuf[column], buf, bytes); in nand_do_write_ops()
3266 wbuf = chip->buffers->databuf; in nand_do_write_ops()
3275 memset(chip->oob_poi, 0xff, mtd->oobsize); in nand_do_write_ops()
3277 ret = chip->write_page(mtd, chip, column, bytes, wbuf, in nand_do_write_ops()
3291 page = realpage & chip->pagemask; in nand_do_write_ops()
3295 chip->select_chip(mtd, -1); in nand_do_write_ops()
3296 chip->select_chip(mtd, chipnr); in nand_do_write_ops()
3305 chip->select_chip(mtd, -1); in nand_do_write_ops()
3323 struct nand_chip *chip = mtd_to_nand(mtd); in panic_nand_write() local
3328 panic_nand_wait(mtd, chip, 400); in panic_nand_write()
3331 panic_nand_get_device(chip, mtd, FL_WRITING); in panic_nand_write()
3356 struct nand_chip *chip = mtd_to_nand(mtd); in nand_do_write_oob() local
3379 ((mtd->size >> chip->page_shift) - in nand_do_write_oob()
3380 (to >> chip->page_shift)) * len)) { in nand_do_write_oob()
3386 chipnr = (int)(to >> chip->chip_shift); in nand_do_write_oob()
3394 nand_reset(chip, chipnr); in nand_do_write_oob()
3396 chip->select_chip(mtd, chipnr); in nand_do_write_oob()
3399 page = (int)(to >> chip->page_shift); in nand_do_write_oob()
3403 chip->select_chip(mtd, -1); in nand_do_write_oob()
3408 if (page == chip->pagebuf) in nand_do_write_oob()
3409 chip->pagebuf = -1; in nand_do_write_oob()
3414 status = chip->ecc.write_oob_raw(mtd, chip, page & chip->pagemask); in nand_do_write_oob()
3416 status = chip->ecc.write_oob(mtd, chip, page & chip->pagemask); in nand_do_write_oob()
3418 chip->select_chip(mtd, -1); in nand_do_write_oob()
3479 struct nand_chip *chip = mtd_to_nand(mtd); in single_erase() local
3483 eraseblock = page >> (chip->phys_erase_shift - chip->page_shift); in single_erase()
3485 return nand_erase_op(chip, eraseblock); in single_erase()
3512 struct nand_chip *chip = mtd_to_nand(mtd); in nand_erase_nand() local
3526 page = (int)(instr->addr >> chip->page_shift); in nand_erase_nand()
3527 chipnr = (int)(instr->addr >> chip->chip_shift); in nand_erase_nand()
3530 pages_per_block = 1 << (chip->phys_erase_shift - chip->page_shift); in nand_erase_nand()
3533 chip->select_chip(mtd, chipnr); in nand_erase_nand()
3553 chip->page_shift, allowbbt)) { in nand_erase_nand()
3564 if (page <= chip->pagebuf && chip->pagebuf < in nand_erase_nand()
3566 chip->pagebuf = -1; in nand_erase_nand()
3568 status = chip->erase(mtd, page & chip->pagemask); in nand_erase_nand()
3576 ((loff_t)page << chip->page_shift); in nand_erase_nand()
3581 len -= (1ULL << chip->phys_erase_shift); in nand_erase_nand()
3585 if (len && !(page & chip->pagemask)) { in nand_erase_nand()
3587 chip->select_chip(mtd, -1); in nand_erase_nand()
3588 chip->select_chip(mtd, chipnr); in nand_erase_nand()
3598 chip->select_chip(mtd, -1); in nand_erase_nand()
3632 struct nand_chip *chip = mtd_to_nand(mtd); in nand_block_isbad() local
3633 int chipnr = (int)(offs >> chip->chip_shift); in nand_block_isbad()
3638 chip->select_chip(mtd, chipnr); in nand_block_isbad()
3642 chip->select_chip(mtd, -1); in nand_block_isbad()
3675 static int nand_onfi_set_features(struct mtd_info *mtd, struct nand_chip *chip, in nand_onfi_set_features() argument
3679 if (!chip->onfi_version || in nand_onfi_set_features()
3680 !(le16_to_cpu(chip->onfi_params.opt_cmd) in nand_onfi_set_features()
3685 return nand_set_features_op(chip, addr, subfeature_param); in nand_onfi_set_features()
3695 static int nand_onfi_get_features(struct mtd_info *mtd, struct nand_chip *chip, in nand_onfi_get_features() argument
3699 if (!chip->onfi_version || in nand_onfi_get_features()
3700 !(le16_to_cpu(chip->onfi_params.opt_cmd) in nand_onfi_get_features()
3705 return nand_get_features_op(chip, addr, subfeature_param); in nand_onfi_get_features()
3709 static void nand_set_defaults(struct nand_chip *chip, int busw) in nand_set_defaults() argument
3712 if (!chip->chip_delay) in nand_set_defaults()
3713 chip->chip_delay = 20; in nand_set_defaults()
3716 if (chip->cmdfunc == NULL) in nand_set_defaults()
3717 chip->cmdfunc = nand_command; in nand_set_defaults()
3720 if (chip->waitfunc == NULL) in nand_set_defaults()
3721 chip->waitfunc = nand_wait; in nand_set_defaults()
3723 if (!chip->select_chip) in nand_set_defaults()
3724 chip->select_chip = nand_select_chip; in nand_set_defaults()
3727 if (!chip->onfi_set_features) in nand_set_defaults()
3728 chip->onfi_set_features = nand_onfi_set_features; in nand_set_defaults()
3729 if (!chip->onfi_get_features) in nand_set_defaults()
3730 chip->onfi_get_features = nand_onfi_get_features; in nand_set_defaults()
3733 if (!chip->read_byte || chip->read_byte == nand_read_byte) in nand_set_defaults()
3734 chip->read_byte = busw ? nand_read_byte16 : nand_read_byte; in nand_set_defaults()
3735 if (!chip->read_word) in nand_set_defaults()
3736 chip->read_word = nand_read_word; in nand_set_defaults()
3737 if (!chip->block_bad) in nand_set_defaults()
3738 chip->block_bad = nand_block_bad; in nand_set_defaults()
3739 if (!chip->block_markbad) in nand_set_defaults()
3740 chip->block_markbad = nand_default_block_markbad; in nand_set_defaults()
3741 if (!chip->write_buf || chip->write_buf == nand_write_buf) in nand_set_defaults()
3742 chip->write_buf = busw ? nand_write_buf16 : nand_write_buf; in nand_set_defaults()
3743 if (!chip->write_byte || chip->write_byte == nand_write_byte) in nand_set_defaults()
3744 chip->write_byte = busw ? nand_write_byte16 : nand_write_byte; in nand_set_defaults()
3745 if (!chip->read_buf || chip->read_buf == nand_read_buf) in nand_set_defaults()
3746 chip->read_buf = busw ? nand_read_buf16 : nand_read_buf; in nand_set_defaults()
3747 if (!chip->scan_bbt) in nand_set_defaults()
3748 chip->scan_bbt = nand_default_bbt; in nand_set_defaults()
3750 if (!chip->controller) { in nand_set_defaults()
3751 chip->controller = &chip->hwcontrol; in nand_set_defaults()
3752 spin_lock_init(&chip->controller->lock); in nand_set_defaults()
3753 init_waitqueue_head(&chip->controller->wq); in nand_set_defaults()
3756 if (!chip->buf_align) in nand_set_defaults()
3757 chip->buf_align = 1; in nand_set_defaults()
3793 struct nand_chip *chip, struct nand_onfi_params *p) in nand_flash_detect_ext_param_page() argument
3809 ret = nand_read_param_page_op(chip, 0, NULL, 0); in nand_flash_detect_ext_param_page()
3814 ret = nand_change_read_column_op(chip, in nand_flash_detect_ext_param_page()
3857 chip->ecc_strength_ds = ecc->ecc_bits; in nand_flash_detect_ext_param_page()
3858 chip->ecc_step_ds = 1 << ecc->codeword_size; in nand_flash_detect_ext_param_page()
3868 struct nand_chip *chip = mtd_to_nand(mtd); in nand_setup_read_retry_micron() local
3871 return chip->onfi_set_features(mtd, chip, ONFI_FEATURE_ADDR_READ_RETRY, in nand_setup_read_retry_micron()
3878 static void nand_onfi_detect_micron(struct nand_chip *chip, in nand_onfi_detect_micron() argument
3886 chip->read_retries = micron->read_retry_options; in nand_onfi_detect_micron()
3887 chip->setup_read_retry = nand_setup_read_retry_micron; in nand_onfi_detect_micron()
3893 static int nand_flash_detect_onfi(struct mtd_info *mtd, struct nand_chip *chip, in nand_flash_detect_onfi() argument
3896 struct nand_onfi_params *p = &chip->onfi_params; in nand_flash_detect_onfi()
3901 ret = nand_readid_op(chip, 0x20, id, sizeof(id)); in nand_flash_detect_onfi()
3905 ret = nand_read_param_page_op(chip, 0, NULL, 0); in nand_flash_detect_onfi()
3910 ret = nand_read_data_op(chip, p, sizeof(*p), true); in nand_flash_detect_onfi()
3928 chip->onfi_version = 23; in nand_flash_detect_onfi()
3930 chip->onfi_version = 22; in nand_flash_detect_onfi()
3932 chip->onfi_version = 21; in nand_flash_detect_onfi()
3934 chip->onfi_version = 20; in nand_flash_detect_onfi()
3936 chip->onfi_version = 10; in nand_flash_detect_onfi()
3938 if (!chip->onfi_version) { in nand_flash_detect_onfi()
3961 chip->chipsize = 1 << (fls(le32_to_cpu(p->blocks_per_lun)) - 1); in nand_flash_detect_onfi()
3962 chip->chipsize *= (uint64_t)mtd->erasesize * p->lun_count; in nand_flash_detect_onfi()
3963 chip->bits_per_cell = p->bits_per_cell; in nand_flash_detect_onfi()
3965 if (onfi_feature(chip) & ONFI_FEATURE_16_BIT_BUS) in nand_flash_detect_onfi()
3971 chip->ecc_strength_ds = p->ecc_bits; in nand_flash_detect_onfi()
3972 chip->ecc_step_ds = 512; in nand_flash_detect_onfi()
3973 } else if (chip->onfi_version >= 21 && in nand_flash_detect_onfi()
3974 (onfi_feature(chip) & ONFI_FEATURE_EXT_PARAM_PAGE)) { in nand_flash_detect_onfi()
3982 if (mtd->writesize > 512 && chip->cmdfunc == nand_command) in nand_flash_detect_onfi()
3983 chip->cmdfunc = nand_command_lp; in nand_flash_detect_onfi()
3986 if (nand_flash_detect_ext_param_page(mtd, chip, p)) in nand_flash_detect_onfi()
3993 nand_onfi_detect_micron(chip, p); in nand_flash_detect_onfi()
3998 static int nand_flash_detect_onfi(struct mtd_info *mtd, struct nand_chip *chip, in nand_flash_detect_onfi() argument
4008 static int nand_flash_detect_jedec(struct mtd_info *mtd, struct nand_chip *chip, in nand_flash_detect_jedec() argument
4011 struct nand_jedec_params *p = &chip->jedec_params; in nand_flash_detect_jedec()
4017 ret = nand_readid_op(chip, 0x40, id, sizeof(id)); in nand_flash_detect_jedec()
4021 ret = nand_read_param_page_op(chip, 0x40, NULL, 0); in nand_flash_detect_jedec()
4026 ret = nand_read_data_op(chip, p, sizeof(*p), true); in nand_flash_detect_jedec()
4043 chip->jedec_version = 10; in nand_flash_detect_jedec()
4045 chip->jedec_version = 1; /* vendor specific version */ in nand_flash_detect_jedec()
4047 if (!chip->jedec_version) { in nand_flash_detect_jedec()
4066 chip->chipsize = 1 << (fls(le32_to_cpu(p->blocks_per_lun)) - 1); in nand_flash_detect_jedec()
4067 chip->chipsize *= (uint64_t)mtd->erasesize * p->lun_count; in nand_flash_detect_jedec()
4068 chip->bits_per_cell = p->bits_per_cell; in nand_flash_detect_jedec()
4070 if (jedec_feature(chip) & JEDEC_FEATURE_16_BIT_BUS) in nand_flash_detect_jedec()
4079 chip->ecc_strength_ds = ecc->ecc_bits; in nand_flash_detect_jedec()
4080 chip->ecc_step_ds = 1 << ecc->codeword_size; in nand_flash_detect_jedec()
4162 static void nand_decode_ext_id(struct mtd_info *mtd, struct nand_chip *chip, in nand_decode_ext_id() argument
4167 chip->bits_per_cell = nand_get_bits_per_cell(id_data[2]); in nand_decode_ext_id()
4183 !nand_is_slc(chip) && id_data[5] != 0x00) { in nand_decode_ext_id()
4218 !nand_is_slc(chip)) { in nand_decode_ext_id()
4281 nand_is_slc(chip) && in nand_decode_ext_id()
4295 static void nand_decode_id(struct mtd_info *mtd, struct nand_chip *chip, in nand_decode_id() argument
4307 chip->bits_per_cell = 1; in nand_decode_id()
4329 struct nand_chip *chip, u8 id_data[8]) in nand_decode_bbm_options() argument
4334 if (mtd->writesize > 512 || (chip->options & NAND_BUSWIDTH_16)) in nand_decode_bbm_options()
4335 chip->badblockpos = NAND_LARGE_BADBLOCK_POS; in nand_decode_bbm_options()
4337 chip->badblockpos = NAND_SMALL_BADBLOCK_POS; in nand_decode_bbm_options()
4345 if (!nand_is_slc(chip) && in nand_decode_bbm_options()
4348 chip->bbt_options |= NAND_BBT_SCANLASTPAGE; in nand_decode_bbm_options()
4349 else if ((nand_is_slc(chip) && in nand_decode_bbm_options()
4357 chip->bbt_options |= NAND_BBT_SCAN2NDPAGE; in nand_decode_bbm_options()
4365 static bool find_full_id_nand(struct mtd_info *mtd, struct nand_chip *chip, in find_full_id_nand() argument
4373 chip->bits_per_cell = nand_get_bits_per_cell(id_data[2]); in find_full_id_nand()
4374 chip->chipsize = (uint64_t)type->chipsize << 20; in find_full_id_nand()
4375 chip->options |= type->options; in find_full_id_nand()
4376 chip->ecc_strength_ds = NAND_ECC_STRENGTH(type); in find_full_id_nand()
4377 chip->ecc_step_ds = NAND_ECC_STEP(type); in find_full_id_nand()
4378 chip->onfi_timing_mode_default = in find_full_id_nand()
4395 struct nand_chip *chip, in nand_get_flash_type() argument
4407 ret = nand_reset(chip, 0); in nand_get_flash_type()
4412 chip->select_chip(mtd, 0); in nand_get_flash_type()
4415 ret = nand_readid_op(chip, 0, id_data, 2); in nand_get_flash_type()
4431 ret = nand_readid_op(chip, 0, id_data, 8); in nand_get_flash_type()
4446 if (find_full_id_nand(mtd, chip, type, id_data, &busw)) in nand_get_flash_type()
4453 chip->onfi_version = 0; in nand_get_flash_type()
4456 if (nand_flash_detect_onfi(mtd, chip, &busw)) in nand_get_flash_type()
4460 if (nand_flash_detect_jedec(mtd, chip, &busw)) in nand_get_flash_type()
4470 chip->chipsize = (uint64_t)type->chipsize << 20; in nand_get_flash_type()
4474 nand_decode_ext_id(mtd, chip, id_data, &busw); in nand_get_flash_type()
4476 nand_decode_id(mtd, chip, type, id_data, &busw); in nand_get_flash_type()
4479 chip->options |= type->options; in nand_get_flash_type()
4486 chip->options &= ~NAND_SAMSUNG_LP_OPTIONS; in nand_get_flash_type()
4495 if (chip->options & NAND_BUSWIDTH_AUTO) { in nand_get_flash_type()
4496 WARN_ON(chip->options & NAND_BUSWIDTH_16); in nand_get_flash_type()
4497 chip->options |= busw; in nand_get_flash_type()
4498 nand_set_defaults(chip, busw); in nand_get_flash_type()
4499 } else if (busw != (chip->options & NAND_BUSWIDTH_16)) { in nand_get_flash_type()
4508 (chip->options & NAND_BUSWIDTH_16) ? 16 : 8, in nand_get_flash_type()
4513 nand_decode_bbm_options(mtd, chip, id_data); in nand_get_flash_type()
4516 chip->page_shift = ffs(mtd->writesize) - 1; in nand_get_flash_type()
4518 chip->pagemask = (chip->chipsize >> chip->page_shift) - 1; in nand_get_flash_type()
4520 chip->bbt_erase_shift = chip->phys_erase_shift = in nand_get_flash_type()
4522 if (chip->chipsize & 0xffffffff) in nand_get_flash_type()
4523 chip->chip_shift = ffs((unsigned)chip->chipsize) - 1; in nand_get_flash_type()
4525 chip->chip_shift = ffs((unsigned)(chip->chipsize >> 32)); in nand_get_flash_type()
4526 chip->chip_shift += 32 - 1; in nand_get_flash_type()
4529 if (chip->chip_shift - chip->page_shift > 16) in nand_get_flash_type()
4530 chip->options |= NAND_ROW_ADDR_3; in nand_get_flash_type()
4532 chip->badblockbits = 8; in nand_get_flash_type()
4533 chip->erase = single_erase; in nand_get_flash_type()
4536 if (mtd->writesize > 512 && chip->cmdfunc == nand_command) in nand_get_flash_type()
4537 chip->cmdfunc = nand_command_lp; in nand_get_flash_type()
4543 if (chip->onfi_version) in nand_get_flash_type()
4545 chip->onfi_params.model); in nand_get_flash_type()
4546 else if (chip->jedec_version) in nand_get_flash_type()
4548 chip->jedec_params.model); in nand_get_flash_type()
4553 if (chip->jedec_version) in nand_get_flash_type()
4555 chip->jedec_params.model); in nand_get_flash_type()
4565 (int)(chip->chipsize >> 20), nand_is_slc(chip) ? "SLC" : "MLC", in nand_get_flash_type()
4574 static int nand_dt_init(struct mtd_info *mtd, struct nand_chip *chip, int node) in nand_dt_init() argument
4582 chip->options |= NAND_BUSWIDTH_16; in nand_dt_init()
4585 chip->bbt_options |= NAND_BBT_USE_FLASH; in nand_dt_init()
4614 chip->ecc.mode = ecc_mode; in nand_dt_init()
4617 chip->ecc.strength = ecc_strength; in nand_dt_init()
4620 chip->ecc.size = ecc_step; in nand_dt_init()
4623 chip->ecc.options |= NAND_ECC_MAXIMIZE; in nand_dt_init()
4628 static int nand_dt_init(struct mtd_info *mtd, struct nand_chip *chip, int node) in nand_dt_init() argument
4648 struct nand_chip *chip = mtd_to_nand(mtd); in nand_scan_ident() local
4652 if (chip->flash_node) { in nand_scan_ident()
4653 ret = nand_dt_init(mtd, chip, chip->flash_node); in nand_scan_ident()
4659 nand_set_defaults(chip, chip->options & NAND_BUSWIDTH_16); in nand_scan_ident()
4662 type = nand_get_flash_type(mtd, chip, &nand_maf_id, in nand_scan_ident()
4666 if (!(chip->options & NAND_SCAN_SILENT_NODEV)) in nand_scan_ident()
4668 chip->select_chip(mtd, -1); in nand_scan_ident()
4673 ret = nand_init_data_interface(chip); in nand_scan_ident()
4685 ret = nand_setup_data_interface(chip, 0); in nand_scan_ident()
4689 chip->select_chip(mtd, -1); in nand_scan_ident()
4696 nand_reset(chip, i); in nand_scan_ident()
4698 chip->select_chip(mtd, i); in nand_scan_ident()
4700 nand_readid_op(chip, 0, id, sizeof(id)); in nand_scan_ident()
4704 chip->select_chip(mtd, -1); in nand_scan_ident()
4707 chip->select_chip(mtd, -1); in nand_scan_ident()
4716 chip->numchips = i; in nand_scan_ident()
4717 mtd->size = i * chip->chipsize; in nand_scan_ident()
4733 int nand_check_ecc_caps(struct nand_chip *chip, in nand_check_ecc_caps() argument
4736 struct mtd_info *mtd = nand_to_mtd(chip); in nand_check_ecc_caps()
4738 int preset_step = chip->ecc.size; in nand_check_ecc_caps()
4739 int preset_strength = chip->ecc.strength; in nand_check_ecc_caps()
4772 chip->ecc.bytes = ecc_bytes; in nand_check_ecc_caps()
4795 int nand_match_ecc_req(struct nand_chip *chip, in nand_match_ecc_req() argument
4798 struct mtd_info *mtd = nand_to_mtd(chip); in nand_match_ecc_req()
4800 int req_step = chip->ecc_step_ds; in nand_match_ecc_req()
4801 int req_strength = chip->ecc_strength_ds; in nand_match_ecc_req()
4862 chip->ecc.size = best_step; in nand_match_ecc_req()
4863 chip->ecc.strength = best_strength; in nand_match_ecc_req()
4864 chip->ecc.bytes = best_ecc_bytes; in nand_match_ecc_req()
4879 int nand_maximize_ecc(struct nand_chip *chip, in nand_maximize_ecc() argument
4882 struct mtd_info *mtd = nand_to_mtd(chip); in nand_maximize_ecc()
4898 if (chip->ecc.size && step_size != chip->ecc.size) in nand_maximize_ecc()
4935 chip->ecc.size = best_step; in nand_maximize_ecc()
4936 chip->ecc.strength = best_strength; in nand_maximize_ecc()
4937 chip->ecc.bytes = best_ecc_bytes; in nand_maximize_ecc()
4959 struct nand_chip *chip = mtd_to_nand(mtd); in nand_ecc_strength_good() local
4960 struct nand_ecc_ctrl *ecc = &chip->ecc; in nand_ecc_strength_good()
4963 if (ecc->size == 0 || chip->ecc_step_ds == 0) in nand_ecc_strength_good()
4972 ds_corr = (mtd->writesize * chip->ecc_strength_ds) / chip->ecc_step_ds; in nand_ecc_strength_good()
4974 return corr >= ds_corr && ecc->strength >= chip->ecc_strength_ds; in nand_ecc_strength_good()
4977 static bool invalid_ecc_page_accessors(struct nand_chip *chip) in invalid_ecc_page_accessors() argument
4979 struct nand_ecc_ctrl *ecc = &chip->ecc; in invalid_ecc_page_accessors()
4992 (NAND_HAS_SUBPAGE_READ(chip) && !ecc->read_subpage) || in invalid_ecc_page_accessors()
4993 (NAND_HAS_SUBPAGE_WRITE(chip) && !ecc->write_subpage && in invalid_ecc_page_accessors()
5008 struct nand_chip *chip = mtd_to_nand(mtd); in nand_scan_tail() local
5009 struct nand_ecc_ctrl *ecc = &chip->ecc; in nand_scan_tail()
5013 BUG_ON((chip->bbt_options & NAND_BBT_NO_OOB_BBM) && in nand_scan_tail()
5014 !(chip->bbt_options & NAND_BBT_USE_FLASH)); in nand_scan_tail()
5016 if (invalid_ecc_page_accessors(chip)) { in nand_scan_tail()
5021 if (!(chip->options & NAND_OWN_BUFFERS)) { in nand_scan_tail()
5023 chip->buffers = nbuf; in nand_scan_tail()
5025 if (!chip->buffers) in nand_scan_tail()
5030 chip->oob_poi = chip->buffers->databuf + mtd->writesize; in nand_scan_tail()
5058 if (!chip->write_page) in nand_scan_tail()
5059 chip->write_page = nand_write_page; in nand_scan_tail()
5229 if (!(chip->options & NAND_NO_SUBPAGE_WRITE) && nand_is_slc(chip)) { in nand_scan_tail()
5241 chip->subpagesize = mtd->writesize >> mtd->subpage_sft; in nand_scan_tail()
5244 chip->state = FL_READY; in nand_scan_tail()
5247 chip->pagebuf = -1; in nand_scan_tail()
5253 if (chip->page_shift > 9) in nand_scan_tail()
5254 chip->options |= NAND_SUBPAGE_READ; in nand_scan_tail()
5262 mtd->type = nand_is_slc(chip) ? MTD_NANDFLASH : MTD_MLCNANDFLASH; in nand_scan_tail()
5263 mtd->flags = (chip->options & NAND_ROM) ? MTD_CAP_ROM : in nand_scan_tail()